3jt SSKrSSKJr SSKrSSKrSSKJrJr SSK J r J r J r SSK Jr SSKJrJrJr \ "5(aSSKr\ R*"\5rSS \S \S \S S \R44Sjjr"SS\\5rg)N)Literal) ConfigMixinregister_to_config) deprecateis_scipy_availablelogging) randn_tensor)KarrasDiffusionSchedulersSchedulerMixinSchedulerOutputnum_diffusion_timestepsmax_betaalpha_transform_type)cosineexplaplacereturnc :US:XaSnO"US:XaSnOUS:XaSnO[SU35e/n[U5H<nXP- nUS-U- nUR[SU"U5U"U5- - U55 M> [R "U[R S 9$) 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`, defaults to `0.999`): The maximum beta to use; use values lower than 1 to avoid numerical instability. alpha_transform_type (`str`, defaults to `"cosine"`): The type of noise schedule for `alpha_bar`. Choose from `cosine`, `exp`, or `laplace`. Returns: `torch.Tensor`: The betas used by the scheduler to step the model outputs. rch[R"US-S- [R-S- 5S-$)NgMb?gT㥛 ?r)mathcospits n/home/wildlama/miniconda3/lib/python3.13/site-packages/diffusers/schedulers/scheduling_dpmsolver_singlestep.py alpha_bar_fn)betas_for_alpha_bar..alpha_bar_fn>s-88QY%/$''9A=>!C Crc S[R"SSU- 5-[R"SS[R"SU- 5-- S-5-n[R"U5n[R "USU-- 5$)Ngr ?rgư>)rcopysignlogfabsrsqrt)rlmbsnrs rrrCsmq#'22TXXa!diiPSVWPWFXBX>X[_>_5``C((3-C99SAG_- -r rc4[R"US-5$)Ng()rrrs rrrJs88AI& &r z"Unsupported alpha_transform_type: r dtype) ValueErrorrangeappendmintorchtensorfloat32)rrrrbetasit1t2s rbetas_for_alpha_barr7$s0x' D  * .  & '=>R=STUU E * +  (!e. . S\"- R0@@@(KL, <<U]] 33r c2\rSrSrSr\VVs/sHoR PM snnrSr\ SSSSSS S S S S SSS S S S S S S\ "S5*SS S4S\ S\ S\ S\ SS\ R\\ -S-S\ S\ SS\S\ S\ S\ S S!\ S"S#\S$\S%\S&\S'\S(\ S)\ S*S+\ S,\ S-S-S.\S/\ SS0S40S1jj5rS2\ S0\\ 4S3jr\S0\ 4S4j5r\S0\ 4S5j5rS`S6\ S0S4S7jjrSaS2\ S8\\R2-S9\ S-S:\\ S-4S;jjrS<\R6S0\R64S=jrS>\ RS?\ RS0\ R4S@jrS>\R6S0\\R6\R644SAjrSB\R6S2\ S0\R64SCjr SB\R6S2\ S0\R64SDjr!SbSB\R6S2\ SE\ SF\ S0\R64 SGjjr"SSH.SI\R6S<\R6S-S0\R64SJjjr#SSSK.SI\R6S<\R6S-SL\R6S-S0\R64SMjjr$SSSK.SN\\R6S<\R6S-SL\R6S-S0\R64SOjjr%SSSK.SN\\R6S<\R6S-SL\R6S-S0\R64SPjjr&SSSSQ.SN\\R6S<\R6S-SR\ SL\R6S-S0\R64 SSjjr'ScST\ \R6-SU\R6S-S0\ 4SVjjr(ST\ \R6-S0S4SWjr)SdSI\R6ST\ \R6-S<\R6SX\RTS-SY\S0\+\-4 SZjjr,S<\R6S0\R64S[jr-S\\R6SL\R6S:\R\S0\R64S]jr/S0\ 4S^jr0S_r1gs snnf)eDPMSolverSinglestepSchedulerXu `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 (`"linear"`, `"scaled_linear"`, or `"squaredcos_cap_v2"`, 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` or `list[float]`, *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 (`"epsilon"`, `"sample"`, `"v_prediction"`, or `"flow_prediction"`, defaults to `"epsilon"`): Prediction type of the scheduler function; can be `epsilon` (predicts the noise of the diffusion process), `sample` (directly predicts the noisy sample`), `v_prediction` (see section 2.4 of [Imagen Video](https://huggingface.co/papers/2210.02303) paper), or `flow_prediction`. 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 (`"dpmsolver"`, `"dpmsolver++"`, or `"sde-dpmsolver++"`, defaults to `"dpmsolver++"`): Algorithm type for the solver; can be `dpmsolver`, `dpmsolver++`, or `sde-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 (`"midpoint"` or `"heun"`, 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 `False`): 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}. use_exponential_sigmas (`bool`, *optional*, defaults to `False`): Whether to use exponential sigmas for step sizes in the noise schedule during the sampling process. use_beta_sigmas (`bool`, *optional*, defaults to `False`): Whether to use beta sigmas for step sizes in the noise schedule during the sampling process. Refer to [Beta Sampling is All You Need](https://huggingface.co/papers/2407.12173) for more information. use_flow_sigmas (`bool`, *optional*, defaults to `False`): Whether to use flow sigmas for step sizes in the noise schedule during the sampling process. flow_shift (`float`, *optional*, defaults to `1.0`): The flow shift parameter for flow-based models. final_sigmas_type (`"zero"` or `"sigma_min"`, *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 (`"learned"` or `"learned_range"`, *optional*): Set to `"learned"` or `"learned_range"` for diffusion models that predict variance. If set, the model's output contains the predicted Gaussian variance. use_dynamic_shifting (`bool`, defaults to `False`): Whether to use dynamic shifting for the noise schedule. time_shift_type (`"exponential"`, defaults to `"exponential"`): The type of time shifting to apply. r ig-C6?g{Gz?linearNrepsilonFgףp= ?? dpmsolver++midpointzeroinf exponentialnum_train_timesteps beta_startbeta_end beta_schedule)r; scaled_linearsquaredcos_cap_v2 trained_betas solver_orderprediction_type)r<sample v_predictionflow_prediction thresholdingdynamic_thresholding_ratiosample_max_valuealgorithm_type dpmsolverr>sde-dpmsolver++ solver_typer?heunlower_order_finaluse_karras_sigmasuse_exponential_sigmasuse_beta_sigmasuse_flow_sigmas flow_shiftfinal_sigmas_type)r@ sigma_minlambda_min_clipped variance_typelearned learned_rangeuse_dynamic_shiftingtime_shift_typerc@URR(a[5(d [S5e[ URRURR URR /5S:a [S5eU S:XaSn[SSU5 Ub)[R"U[RS9Ul OUS :Xa*[R"X#U[RS9Ul OkUS :Xa4[R"US -US -U[RS9S -Ul O1US :Xa[U5Ul O[USUR 35eSUR- Ul[R$"UR"SS9Ul[R("UR&5Ul[R("SUR&- 5Ul[R."UR*5[R."UR,5- UlSUR&- UR&- S -UlSUlU S;a0U S:XaUR7SS9 O[U SUR 35eU S;a0U S;aUR7SS9 O[U SUR 35eU S;aUS:Xa[SUSU S35eSUl[:R"SUS- U[:RS9SSS2R=5n[R>"U5Ul S/U-Ul!SUl"URGU5Ul$SUl%SUl&UR2ROS 5Ulg)!Nz:Make sure to install scipy if you want to use beta sigmas.r znOnly one of `config.use_beta_sigmas`, `config.use_exponential_sigmas`, `config.use_karras_sigmas` can be used.rTzalgorithm_type `dpmsolver` is deprecated and will be removed in a future version. Choose from `dpmsolver++` or `sde-dpmsolver++` insteadzalgorithm_types=dpmsolver1.0.0r*r;rGr"rrHz is not implemented for r=rdimrSdeisr>)rRrW)logrhobh1bh2r?)rVr>rUr@z`final_sigmas_type` z' is not supported for `algorithm_type` z$. Please choose `sigma_min` instead.cpu)(configr\r ImportErrorsumr[rZr,rr0r1r2r3linspacer7NotImplementedError __class__alphascumprodalphas_cumprodr&alpha_tsigma_tr$lambda_tsigmasinit_noise_sigmarnum_inference_stepsnpcopy from_numpy timesteps model_outputsrLget_order_list order_list _step_index _begin_indexto)selfrCrDrErFrIrJrKrOrPrQrRrVrYrZr[r\r]r^r_rarbrfrgdeprecation_messagers r__init__%DPMSolverSinglestepScheduler.__init__sG6 ;; & &/A/C/CZ[ [  ++T[[-O-OQUQ\Q\QnQno pst tA  [ (#m  17QY^YfYfgDJ o - C3H[chcpcpquvvDJ 1 1,-@ADJ%7OPTP^P^O_&`a aDJJ& #mmDKKQ?zz$"5"56 zz!d&9&9"9:  $,,/%))DLL2II D///43F3FF3N !$ !P P'''}'E)^,< 3 is not supported by this schedulerr)r rrr rr@rq)rsrJr,rYr_)rrstepsorderorderss rr+DPMSolverSinglestepScheduler.get_order_lists`$ (( 19KL L ;; ( (z19>&%1*q.9QFBaSHFQY!^&%1*5;F&%1*5A>F!19>VuzA~6!Q?FVuz2aS8F!uz"eqj1!Q5A:.!u ;; ( (F 2F2J r cUR$)z The index counter for current timestep. It will increase 1 after each scheduler step. Returns: `int` or `None`: The current step index. )rrs r step_index'DPMSolverSinglestepScheduler.step_index)sr cUR$)z The index for the first timestep. It should be set from pipeline with `set_begin_index` method. Returns: `int` or `None`: The begin index. rrs r begin_index(DPMSolverSinglestepScheduler.begin_index4s   r rcXlg)z Sets the begin index for the scheduler. This function should be run from pipeline before the inference. Args: begin_index (`int`, defaults to `0`): The begin index for the scheduler. Nr)rrs rset_begin_index,DPMSolverSinglestepScheduler.set_begin_index@s (r devicemurc Ub\URR(aURRS:Xde[R"U5URlUcUc [ S5eUbUb [ S5eUb&URR(a [ S5eUb&URR(a [ S5eUb&URR(a [ S5eU=(d [U5nXl Ub4[R"U5R[R5nO[R "[R""UR$S/5URR&5nUR)5n[R*"SURR,S- U- US-5R/5SSS 2SS R15R[R5n[R"SUR2- UR2- S -5n[R4"U5nURR(ax[R""U5R15nUR7XaS 9n[R"UVs/sHoR9X5PM sn5R/5nGOURR(aj[R""U5R15nUR;XaS 9n[R"UVs/sHoR9X5PM sn5nGOURR(aj[R""U5R15nUR=XaS 9n[R"UVs/sHoR9X5PM sn5nGO URR>(a[R*"SSURR,- US-5n S U - n[R""URR U-SURR S- U--- 5SS R15nX`RR,-R15nO6[R@"U[RB"S[U55U5nURRDS :Xa&SUR2S- UR2S- S -n O?URRDS:XaSn O"[ SURRD35e[RF"Xj//5R[RH5n[RJ"U5RMUS9Ul'[RJ"U5RMU[RS9Ul(S/URRR-Ul*SUl+URRX(d@XRRR-S:wa$[ZR]S5 UR_SS9 URRX(d>URRDS:Xa$[ZR]S5 UR_SS9 URaU5Ul1SUl2SUl3URNRMS5Ul'gs snfs snfs snf)a Sets the discrete timesteps used for the diffusion chain (to be run before inference). Args: num_inference_steps (`int`, *optional*): 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`. NrBz?Must pass exactly one of `num_inference_steps` or `timesteps`.z;;33 8S8SWd8d dd%'VVBZDKK "  &9+<^_ _  *y/D^_ _  T[[%B%B[\ \  T[[%G%Gbc c  T[[%@%@[\ \1CS^#6  +22288>B[PRehiRij2"$! A 3 33t7J7JJsRSVVF^ ;; ( (WWV_))+F,,v,gFSY!ZSY%"2"25"ESY!Z[aacI [[ / /WWV_))+F11F1lFSY!ZSY%"2"25"ESY!Z[I [[ ( (WWV_))+F**V*eFSY!ZSY%"2"25"ESY!Z[I [[ ( ([[A (G(G$GI\_`I`aF6\FWWT[[33f<T[[E[E[^_E_ciDi@ijklomopuuwF++"A"AAGGIIYYy"))As6{*CVLF ;; ( (K 7t221559L9LQ9OOTWWJ [[ * *f 4JUVZVaVaVsVsUtu  67>>rzzJ&&v.111@ )))477vU[[7Y"Vdkk&>&>> {{,,1D{{G_G_1_cd1d NNs   # #d # ;{{,,1N1NRX1X NNg   # #d # ;--.AB  kknnU+ e"["["[s ]] #]rLcXURnURtp4nU[R[R4;aUR 5nUR X4[R"U5-5nUR5n[R"X`RRSS9n[R"USURRS9nURS5n[R"X*U5U- nUR "X4/UQ76nUR!U5nU$)a  Apply dynamic thresholding to the predicted sample. "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://huggingface.co/papers/2205.11487 Args: sample (`torch.Tensor`): The predicted sample to be thresholded. Returns: `torch.Tensor`: The thresholded sample. r rj)r/max)r+shaper0r2float64floatreshaperprodabsquantilersrPclamprQ unsqueezer)rrLr+ batch_sizechannelsremaining_dims abs_sampless r_threshold_sample.DPMSolverSinglestepScheduler._threshold_samples( 06 - ~  6 6\\^F rww~7N,NOZZ\ NN:{{'M'MST U KK 1$++66  KKNVR+a/ F~F5! r rrc[R"[R"US55nX2SS2[R4- n[R"US:SS9R SS9R URSS- S9nUS-nX%nX&nXs- Xx- - n [R "U SS5n SU - U-X--n U RUR5n U $)at Convert sigma values to corresponding timestep values through interpolation. Args: sigma (`np.ndarray`): The sigma value(s) to convert to timestep(s). log_sigmas (`np.ndarray`): The logarithm of the sigma schedule used for interpolation. Returns: `np.ndarray`: The interpolated timestep value(s) corresponding to the input sigma(s). g|=Nr)axisr)rr ) rr$maximumnewaxiscumsumargmaxcliprr) rrr log_sigmadistslow_idxhigh_idxlowhighwrs rr(DPMSolverSinglestepScheduler._sigma_to_tsFF2::eU34 q"**}55))UaZq188a8@EE*JZJZ[\J]`aJaEbQ;!#_ , GGAq! Ug  , IIekk "r cvURR(a SU- nUnX#4$SUS-S-S-- nX-nX#4$)z Convert sigma values to alpha_t and sigma_t values. Args: sigma (`torch.Tensor`): The sigma value(s) to convert. Returns: `tuple[torch.Tensor, torch.Tensor]`: A tuple containing (alpha_t, sigma_t) values. r rr")rsr])rrr|r}s r_sigma_to_alpha_sigma_t4DPMSolverSinglestepScheduler._sigma_to_alpha_sigma_tsS ;; & &%iGG E1HqLS01GoGr rc[URS5(aURRnOSn[URS5(aURRnOSnUbUOUSR 5nUbUOUSR 5nSn[ R "SSU5nUSU- -nUSU- -nXXx- --U-n U $)a Construct the noise schedule as proposed in [Elucidating the Design Space of Diffusion-Based Generative Models](https://huggingface.co/papers/2206.00364). Args: in_sigmas (`torch.Tensor`): The input sigma values to be converted. num_inference_steps (`int`): The number of inference steps to generate the noise schedule for. Returns: `torch.Tensor`: The converted sigma values following the Karras noise schedule. r`N sigma_maxrqrg@r )hasattrrsr`rrrrv) rrrr`rrhoramp min_inv_rho max_inv_rhors rr/DPMSolverSinglestepScheduler._convert_to_karrass$ 4;; , , --II 4;; , , --II!*!6IIbM [!TIP] > 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. rrNr /missing `sample` as a required keyword argumentrriPassing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`rpr<rcrrLrMrNzprediction_type given as zo must be one of `epsilon`, `sample`, `v_prediction`, or `flow_prediction` for the DPMSolverSinglestepScheduler.rTz\ must be one of `epsilon`, `sample`, or `v_prediction` for the DPMSolverSinglestepScheduler.)rpopr,rrsrRrKrbrrrrOrr|r}) rrrLargskwargsrrr|r}x0_predr<s rconvert_model_output1DPMSolverSinglestepScheduler.convert_model_outputs82"$i!m47J1M >4y1}a !RSS   Z  ;; % %)K K{{**i7;;,,0LL#/2A2#6L DOO4#'#?#?#F !l$::gE,,8&,,> DOO4#'#?#?#F !*W-CC,,0AA++doo6 \#99 / 0K0K/LMaa {{''009N[[ ' '; 6{{**i7;;,,0LL*1bqb51G*G,,8 DOO4#'#?#?#F !l$::gE,,> DOO4#'#?#?#F !073CC / 0K0K/LMLL {{''#'<<#94<<;Q!g$55@009!g$55@N77r rLnoiserc [U5S:aUSOURSS5n[U5S:aUSOURSS5nUc [U5S:aUSnO [S5eUb [SS S 5 Ub [SS S 5 URUR S-URUR pUR U5upUR U 5up[R"U 5[R"U5- n [R"U 5[R"U 5- n X- nURRS :Xa*X- U-U [R"U*5S - -U-- nU$URRS:Xa)X- U-U[R"U5S - -U-- nU$URRS:Xa~UceX- [R"U*5-U-U S[R"SU-5- -U--U[R"S [R"SU-5- 5-U--nW$)a  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_timesteprrrrirPassing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`r>r=rTrU) rrr,rrrrr0r$rsrRrr&)rrrLrrrrrr}sigma_sr|alpha_sr~lambda_shx_ts rdpm_solver_first_order_update:DPMSolverSinglestepScheduler.dpm_solver_first_order_updatesR2"$i!m47J1M#&t9q=QfjjRV6W >4y1}a !RSS   Z   $ ^   ;;t':;T[[=Y77@77@99W% '(::99W% '(::   ;; % % 6$.'UYYr]S=P2QUa1aaC [[ ' '; 6$.'UYYq\C=O2PT`1``C [[ ' '+< <$ $$"UYYr]2f<a%))D1H"556,FGEJJsUYYrAv->'>??%GH   r model_output_listc p [U5S:aUSOURSS5n[U5S:aUSOURSS5nUc [U5S:aUSnO [S5eUb [SSS 5 Ub [SSS 5 URUR S-URUR URUR S- pnUR U5upUR U 5upUR U 5up[R"U 5[R"U5- n[R"U 5[R"U 5- n[R"U 5[R"U 5- nUS US nnUU- UU- nnUU- nUS U- UU- -nnURRS:XaURRS:XaNX- U-U [R"U*5S - -U-- SU [R"U*5S - --U-- nU$URRS:XaOX- U-U [R"U*5S - -U-- U [R"U*5S - U- S --U--nW$URRS:XaURRS:XaLX- U-U[R"U5S - -U-- SU[R"U5S - --U-- nU$URRS:XaMX- U-U[R"U5S - -U-- U[R"U5S - U- S - -U-- nW$URRS:XGaUceURRS:XaX- [R"U*5-U-U S[R"SU-5- -U--SU S[R"SU-5- --U--U[R"S [R"S U-5- 5-U--nU$URRS:XaX- [R"U*5-U-U S[R"SU-5- -U--U S [R"SU-5- SU-- S --U--U[R"S [R"S U-5- 5-U--nW$)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 rrrriPassing `timestep_list` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`rrqrr=r>r?r"rXrTrUrrrr,rrrrr0r$rsrRrVrr&)rr rLrrrrrr}sigma_s0sigma_s1r|alpha_s0alpha_s1r~ lambda_s0 lambda_s1m0m1rh_0r0D0D1r s r)singlestep_dpm_solver_second_order_updateFDPMSolverSinglestepScheduler.singlestep_dpm_solver_second_order_update7sG4$'t9q=QfjjRV6W #&t9q=QfjjRV6W >4y1}a !RSS  $ ^   $ ^  KK!+ , KK ( KK!+ ,$  77@!99(C!99(C99W% '(::IIh'%))H*== IIh'%))H*== "2&(9"(=BI%y9'<3 1WcBh27+B ;; % % 6{{&&*4'61%))QB-#"56"<=W 1" (;<=BCR I((F2'61%))QB-#"56"<=599aR=3#6!";c"ABbHIF =[[ ' '; 6{{&&*4'61%))A,"45;<W ! s(:;r?rXr"rTrUrr)"rr rLrrrrrr}rrsigma_s2r|rralpha_s2r~rr lambda_s2rrm2rrh_1rr1rD1_0D1_1rD2r s" r(singlestep_dpm_solver_third_order_updateEDPMSolverSinglestepScheduler.singlestep_dpm_solver_third_order_updates6$'t9q=QfjjRV6W #&t9q=QfjjRV6W >4y1}a !RSS  $ ^   $ ^  KK!+ , KK ( KK!+ , KK!+ , 1 -8 77@!99(C!99(C!99(C99W% '(::IIh'%))H*== IIh'%))H*== IIh'%))H*== &r*,=b,ACTUWCXB*I ,A9yCX3q#'B Bh27+cBh27-Cd4i"t)#R 0 D4K BG , ;; % % 6{{&&*4'61%))QB-#"56"<=599aR=3#6!";c"ABdJKX O((F2'61%))QB-#"56"<=599aR=3#6!";c"ABbHI599aR=3#6#:ad"BS"HIROPL A[[ ' '; 6{{&&*4'61%))A,"45;<599Q<##5":S"@ATIJ: 1((F2'61%))A,"45;<599Q<##5":S"@ARGH599Q<##5#9QT"AC"GHBNO. #[[ ' '+< <$ $${{&&*4'%))QB-76A# $((;";<BC34!8)<#<"JS"PQUYYZ 3261B+B CCeKL ((F2'%))QB-76A# $((;";<BC34!8)<#<"JS"PQUWWX34!8)<#<q#IdUVh[\_"\_b"bcgiij 3261B+B CCeK L r rLrrrc [U5S:aUSOURSS5n[U5S:aUSOURSS5nUc [U5S:aUSnO [S5eUc [U5S:aUSnO [S 5eUb [SS S 5 Ub [SS S 5 US:XaUR US X$S9$US:XaUR XUS9$US:XaUR XUS9$[SU35e)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 rrrrz.missing `order` as a required keyword argumentrirrrqrzOrder must be 1, 2, 3, got )rrr,rr rr*) rr rLrrrrrrs rsinglestep_dpm_solver_update9DPMSolverSinglestepScheduler.singlestep_dpm_solver_update s=8$'t9q=QfjjRV6W #&t9q=QfjjRV6W >4y1}a !RSS =4y1}Q !QRR  $ ^   $ ^  A:556G6KTZ5h h aZAABSjoAp p aZ@@ARin@o o:5'BC Cr rschedule_timestepscUc URnX!:HR5n[U5S:Xa[UR5S- nU$[U5S:aUSR5nU$USR5nU$)ab Find the index for a given timestep in the schedule. Args: timestep (`int` or `torch.Tensor`): The timestep for which to find the index. schedule_timesteps (`torch.Tensor`, *optional*): The timestep schedule to search in. If `None`, uses `self.timesteps`. Returns: `int`: The index of the timestep in the schedule. rr )rnonzerorr)rrr0index_candidatesrs rindex_for_timestep/DPMSolverSinglestepScheduler.index_for_timestep`s$  %!% .:CCE  A %T^^,q0J ! "Q &)!,113J*!,113Jr cURc[[U[R5(a%UR UR R 5nURU5UlgURUlg)z Initialize the step_index counter for the scheduler. Args: timestep (`int` or `torch.Tensor`): The current timestep for which to initialize the step index. N) r isinstancer0Tensorrrrr4rr)rrs r_init_step_index-DPMSolverSinglestepScheduler._init_step_indexsZ    #(ELL11#;;t~~'<'<=#66x@D #00D r generator return_dictcURc [S5eURcURU5 UR XS9n[ UR RS- 5H"nURUS-URU'M$ XRS'UR RS:Xa*[URXARURS9nOSnURURnURU*cUS-nURU*cMUS:XaX0lUR!URURXS9n U=R"S- slU(dU 4$[%U S 9$) 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` or `torch.Tensor`): The current discrete timestep in the diffusion chain. sample (`torch.Tensor`): A current instance of a sample created by the diffusion process. generator (`torch.Generator`, *optional*): A random number generator for stochastic sampling. return_dict (`bool`, defaults to `True`): 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 rqrU)r;rr+r,) prev_sample)rr,rr9rr-rsrJrrRr rrr+rrLr.rr) rrrrLr;r<r4rrr>s rstep!DPMSolverSinglestepScheduler.stepsx<  # # +s  ?? "  ! !( +000M t{{//!34A$($6$6q1u$=D  q !5!-2 ;; % %): : ""i@S@S[g[m[mEE0  %(0 QJE  %(0 A: K77   t{{%8 A> !;77r cU$)z 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. )rrLrrs rscale_model_input.DPMSolverSinglestepScheduler.scale_model_inputs  r original_samplesc*URRURURS9nURRS:Xav[ R "U5(a[URRUR[ RS9nURUR[ RS9nO@URRUR5nURUR5nURc!UVs/sHo`RXe5PM nnOHURbUR/URS-nOUR/URS-nXGR5n[UR5[UR5:a?URS5n[UR5[UR5:aM?UR!U5upX-X--n U $s snf)a Add noise to the original samples according to the noise schedule at the specified timesteps. Args: original_samples (`torch.Tensor`): The original samples without noise. noise (`torch.Tensor`): The noise to add to the samples. timesteps (`torch.IntTensor`): The timesteps at which to add noise to the samples. Returns: `torch.Tensor`: The noisy samples. rmpsr*rrq)rrrr+typer0is_floating_pointrr2rr4rrflattenrrr) rrErrrr0r step_indicesrr|r} noisy_sampless r add_noise&DPMSolverSinglestepScheduler.add_noises,'7'>'>FVF\F\]  " " ' '5 0U5L5LY5W5W!%!2!23C3J3JRWR_R_!2!` ! %5%<%2W_D _sHc.URR$N)rsrCrs r__len__$DPMSolverSinglestepScheduler.__len__s{{...r )rrr|ryr{r3rr~rrrrLr}rr)r)NNNN)333333?rSrP)NT)2__name__ __module__ __qualname____firstlineno____doc__r name _compatiblesrrrintrrndarraylistboolrrpropertyrrrstrr0rrr8rrtuplerrrrrr rr*r.r4r9 Generatorrr?rC IntTensorrMrQ__static_attributes__).0es00rr9r9XsKFP%>>$=qFF$=>L E$("QY9=[d",1"%Q^3="'"'', % %:@%*5\MDH%*2?1V, V,V, V, MN V, zzDK/$6 V,V,!!WXV,V,%*V, V, MNV,/0V, V, V, !%!V,"#V,$%V,&'V,(##67)V,*"+V,,9:TA-V,.#/V,0!/1V,2 3V,V,p*#*$s)*X C  !S!!(3(t($(%)&* j, j,ell"j, DL j, 9t# j,Z) ))X""" "J U\\ eELLRWR^R^D^>_ ,$ELL$s$W\WcWc$NTW\a\h\hFdg..ll> t# > ||d" > >H'+%) m -m t# m ||d" m mf'+%) x -x t# x ||d" x x|'+%) =D -=D t# =D  =D ||d" =D =DF37" $""LL4/" "J1u||);11*-1 G8llG8 $G8 G8 ??T) G8  G8 5 G8R  %,,  /,,/||/?? /  /b//}#?sO8r9)g+?r)rtypingrnumpyrr0configuration_utilsrrutilsrrr utils.torch_utilsr scheduling_utilsr r r scipy.statsr get_loggerrTrr[rr8r7r9rBr rros"  A::,XX   H % @H14 1414""<=14 \\ 14hH/>;H/r