+h!SSKrSSKJrJrJrJr SSKrSSKrSSK J r J r SSK J r JrJr SSKJr SSKJrJrJr \"5(aSSKr\R0"\5rS S jr"S S \\ 5rg) N)ListOptionalTupleUnion) ConfigMixinregister_to_config) deprecateis_scipy_availablelogging) randn_tensor)KarrasDiffusionSchedulersSchedulerMixinSchedulerOutputc &US:XaSnOUS:XaSnO[SU35e/n[U5H<nXP- nUS-U- nUR[SU"U5U"U5- - U55 M> [R "U[R S9$)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 cosinech[R"US-S- [R-S- 5S-$)NgMb?gT㥛 ?r)mathcospits n/home/james-whalen/.local/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 Cexpc4[R"US-5$)Ng()rrrs rrrBs88AI& &rz"Unsupported alpha_transform_type: rdtype) ValueErrorrangeappendmintorchtensorfloat32)num_diffusion_timestepsmax_betaalpha_transform_typerbetasit1t2s rbetas_for_alpha_barr0$s.x' D  & '=>R=STUU E * +  (!e. . S\"- R0@@@(KL, <<U]] 33rc0\rSrSrSr\VVs/sHoR PM snnrSr\ SSSSSS S S S S SSS S S S S S S\ "S5*SS S4S\ S\ S\ S\ S\ \RS\ S\ S\S\ S\ S\ S\ S\S \ \S!\ \S"\ \S#\ \S$\ \ S%\ \ S&\ S'\ \ S(\S)\ 4.S*jj5rS+\ S,\\ 4S-jr\S.5r\S/5rSVS0\ 4S1jjrSWS+\ S2\\ \R44S3\ \ S4\ \\ 4S5jjrS6\R8S,\R84S7jrS8rS9rS:\R8S,\R84S;jr S:\R8S+\ S,\R84S<jr!SXS:\R8S+\ S=\ S>\ S,\R84 S?jjr"SS@.SA\R8S6\R8S,\R84SBjjr#SSSC.SA\R8S6\R8SD\ \R8S,\R84SEjjr$SSSC.SF\\R8S6\R8SD\ \R8S,\R84SGjjr%SSSC.SF\\R8S6\R8SD\ \R8S,\R84SHjjr&SSSSI.SF\\R8S6\R8SJ\ SD\ \R8S,\R84 SKjjr'SYSLjr(SMr)SZSA\R8SN\\ \R84S6\R8SO\S,\\*\+44 SPjjr,S6\R8S,\R84SQjr-SR\R8SD\R8S4\R\S,\R84SSjr/STr0SUr1gs snnf)[DPMSolverSinglestepSchedulerPu `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++` 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 (`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}. 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. 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. rig-C6?g{Gz?linearNrepsilonFgףp= ?? dpmsolver++midpointzeroinf exponentialnum_train_timesteps beta_startbeta_end beta_schedule trained_betas solver_orderprediction_type thresholdingdynamic_thresholding_ratiosample_max_valuealgorithm_type solver_typelower_order_finaluse_karras_sigmasuse_exponential_sigmasuse_beta_sigmasuse_flow_sigmas flow_shiftfinal_sigmas_typelambda_min_clipped variance_typeuse_dynamic_shiftingtime_shift_typec@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.rznOnly one of `config.use_beta_sigmas`, `config.use_exponential_sigmas`, `config.use_karras_sigmas` can be used. dpmsolverzalgorithm_type `dpmsolver` is deprecated and will be removed in a future version. Choose from `dpmsolver++` or `sde-dpmsolver++` insteadzalgorithm_types=dpmsolver1.0.0r r4 scaled_linear?rsquaredcos_cap_v2z is not implemented for r6rdim)rTr7sde-dpmsolver++deisr7)rF)r8heun)logrhobh1bh2r8)rGr7r[r9z`final_sigmas_type` z' is not supported for `algorithm_type` z$. Please choose `sigma_min` instead.cpu)(configrKr ImportErrorsumrJrIr"r r&r'r(r,linspacer0NotImplementedError __class__alphascumprodalphas_cumprodsqrtalpha_tsigma_tloglambda_tsigmasinit_noise_sigmar num_inference_stepsnpcopy from_numpy timesteps model_outputssampleget_order_list order_list _step_index _begin_indexto)selfr<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRdeprecation_messagerxs 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)rrrrrr9rb)rdrAr"rHrN)rrtstepsorderorderss 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 rcUR$)zW The index counter for current timestep. It will increase 1 after each scheduler step. )r}rs r step_index'DPMSolverSinglestepScheduler.step_indexs rcUR$)za The index for the first timestep. It should be set from pipeline with `set_begin_index` method. r~rs r begin_index(DPMSolverSinglestepScheduler.begin_indexs    rrcXlg)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)rrs rset_begin_index,DPMSolverSinglestepScheduler.set_begin_index$s (rdevicemurxc 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`): 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`. Nr;z?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 ]] #]rzcXURnURtp4nU[R[R4;aUR 5nUR X4[R"U5-5nUR5n[R"X`RRSS9n[R"USURRS9nURS5n[R"X*U5U- nUR "X4/UQ76nUR!U5nU$)aC "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 rrY)r%max)r!shaper&r(float64floatreshaperuprodabsquantilerdrDclamprE unsqueezer)rrzr! 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! rc[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 $)Ng|=r)axisr)rr) rurpmaximumnewaxiscumsumargmaxcliprr) rrr log_sigmadistslow_idxhigh_idxlowhighwrs rr(DPMSolverSinglestepScheduler._sigma_to_tsFF2::eU34 q"**}55))UaZq188a8@EE*JZJZ[\J]`aJaEbQ;!#_ , GGAq! Ug  , IIekk "rcvURR(a SU- nUnX#4$SUS-S-S-- nX-nX#4$)NrrrW)rdrL)rrrnros r_sigma_to_alpha_sigma_t4DPMSolverSinglestepScheduler._sigma_to_alpha_sigma_tsQ ;; & &%iGG E1HqLS01GoGrrc[URS5(aURRnOSn[URS5(aURRnOSnUbUOUSR 5nUbUOUSR 5nSn[ R "SSU5nUSU- -nUSU- -nXXx- --U-n U $)z6Constructs the noise schedule of Karras et al. (2022).rN sigma_maxrbrg@r)hasattrrdrrrrurg) rrrtrrrhoramp min_inv_rho max_inv_rhorrs rr/DPMSolverSinglestepScheduler._convert_to_karrass 4;; , , --II 4;; , , --II!*!6IIbM 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 argumentrxrUPassing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`rar5)learned learned_rangerrz v_predictionflow_predictionzprediction_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"r rdrFrBrPrrrrrCrrnro) rrrzargskwargsrrrnrox0_predr5s rconvert_model_output1DPMSolverSinglestepScheduler.convert_model_output/s8:"$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@N77rrznoiserc [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_timesteprrrxrUrPassing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`r7r6rTr[) rrr"r rrrrr&rprdrFrrm)rrrzrrrrrrosigma_srnalpha_srqlambda_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   rmodel_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_listNrrrrrUPassing `timestep_list` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`rrbrr6r7r8rWr]rTr[rrrr"r rrrrr&rprdrFrGrrm)rrrzrrrrrrosigma_s0sigma_s1rnalpha_s0alpha_s1rq lambda_s0 lambda_s1m0m1rh_0r0D0D1rs r)singlestep_dpm_solver_second_order_updateFDPMSolverSinglestepScheduler.singlestep_dpm_solver_second_order_updatesG4$'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(:;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 rrzrrrc [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. rrNrrrrrz.missing `order` as a required keyword argumentrUr rrbrzOrder must be 1, 2, 3, got )rrr"r rrr$) rrrzrrrrrrs rsinglestep_dpm_solver_update9DPMSolverSinglestepScheduler.singlestep_dpm_solver_updates=8$'t9q=QfjjRV6W #&t9q=QfjjRV6W >4y1}a !RSS =4y1}Q !QRR  $ ^   $ ^  A:556G6KTZ5h h aZAABSjoAp p aZ@@ARin@o o:5'BC CrcUc URnX!:HR5n[U5S:Xa[UR5S- nU$[U5S:aUSR5nU$USR5nU$)Nrr)rxnonzerorr)rrschedule_timestepsindex_candidatesrs rindex_for_timestep/DPMSolverSinglestepScheduler.index_for_timesteps  %!% .:CCE  A %T^^,q0J ! "Q &)!,113J*!,113JrcURc[[U[R5(a%UR UR R 5nURU5UlgURUlg)z6 Initialize the step_index counter for the scheduler. N) r isinstancer&Tensorrrxrr.r}r~)rrs r_init_step_index-DPMSolverSinglestepScheduler._init_step_indexsZ    #(ELL11#;;t~~'<'<=#66x@D #00D rr 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`): 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 schedulerrrrbr[) generatorrr!r&) prev_sample)rtr"rr3rr#rdrAryrFr rrr!r|rzr(r}r) rrrrzr7r5r-rrr8s rstep!DPMSolverSinglestepScheduler.stepsx8  # # +s  ?? "  ! !( +000M t{{//!34A$($6$6q1u$=D  q !5!-2 ;; % %): : ""i@S@S[g[m[mEE0  %(0 QJE  %(0 A: K77   t{{%8 A> !;77rcU$)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. )rrzrrs rscale_model_input.DPMSolverSinglestepScheduler.scale_model_inputcs  roriginal_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)Nrmpsr rrb)rrrrr!typer&is_floating_pointrxr(rr.rrflattenrrr) rr?rrxrrr,r step_indicesrrnro noisy_sampless r add_noise&DPMSolverSinglestepScheduler.add_noisess'7'>'>FVF\F\]  " " ' '5 0U5L5LY5W5W!%!2!23C3J3JRWR_R_!2!` ! %5%<%2W_D _sHc.URR$N)rdr<rs r__len__$DPMSolverSinglestepScheduler.__len__s{{...r)r~r}rnrjrlr,rsrqryrtr|rzrorrrx)r)NNNN)333333?rMrJ)NT)2__name__ __module__ __qualname____firstlineno____doc__rname _compatiblesrr rintstrrrundarrayboolrrr{propertyrrrrr&rrr2rrrrrrrrrr$r(r.r3rrr9r= IntTensorrGrK__static_attributes__).0es00rr2r2PsM>@%>>$=qFF$=>L E$("%.2(",1"%+%"',116*/*/&)+1%*5\M'+%*,1V, V,V, V,  V,   + V,V,V,V,%*V, V,V,V, V,$D>V, !)!V,""$#V,$"$%V,&UO'V,($C=)V,*"+V,, }-V,.#/V,01V,V,p&#&$s)&P  !!(3($(+/")- j, j,c5<<'(j, UO j, DI& j,Z D0 ELLRWR^R^4TW\a\h\h.dgll> >  % > >H $(, m -m m  % m mf $(, x -x x  % x x| $(, =D -=D =D  =D  % =D =D@( 1" E8llE8U\\)*E8 E8  E8 % &E8N  %,,  ,, || ??   D/I ?sMr2)g+?r)rtypingrrrrnumpyrur&configuration_utilsrr utilsr r r utils.torch_utilsr scheduling_utilsrrr scipy.statsr get_loggerrNrr0r2r<rrrfsd" // A::,XX   H % !)4XF/>;F/r