bi!ddlZddlmZmZmZmZddlZddlZddl m Z m Z ddl m Z mZmZddlmZddlmZmZmZerddlZej0eZ d d ZGd d ee Zy) N)ListOptionalTupleUnion) ConfigMixinregister_to_config) deprecateis_scipy_availablelogging) randn_tensor)KarrasDiffusionSchedulersSchedulerMixinSchedulerOutputc $|dk(rd}n|dk(rd}ntd|g}t|D]<}||z }|dz|z }|jtd||||z z |>t j |tj S)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 cosinecftj|dzdz tjzdz dzS)NgMb?gT㥛 ?r)mathcospits o/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/diffusers/schedulers/scheduling_dpmsolver_singlestep.py alpha_bar_fnz)betas_for_alpha_bar..alpha_bar_fn=s-88QY%/$''9A=>!C Cexpc2tj|dzS)Ng()rrrs rrz)betas_for_alpha_bar..alpha_bar_fnBs88AI& &rz"Unsupported alpha_transform_type: rdtype) ValueErrorrangeappendmintorchtensorfloat32)num_diffusion_timestepsmax_betaalpha_transform_typerbetasit1t2s rbetas_for_alpha_barr/$s.x' D  & '=>R=STUU E * +M ( (!e. . S\"- R0@@@(KLM <<U]] 33rc0JeZdZdZeDcgc]}|j c}}ZdZeddddddd d d d d dd d d d d d de d dd dfde de de de de e jde de dede de de de dede ed e ed!e ed"e ed#e e d$e e d%e d&e e d'ed(e f.d)Zd*e d+ee fd,Zed-Zed.ZdTd/e fd0Z dUd*e d1ee ej2fd2e e d3e ee fd4Zd5ej6d+ej6fd6Zd7Zd8Zd9ej6d+ej6fd:Zd9ej6d*e d+ej6fd;Z dVd9ej6d*e dZ!dd?d@ej6d5ej6d+ej6fdAZ"dddBd@ej6d5ej6dCe ej6d+ej6fdDZ#dddBdEeej6d5ej6dCe ej6d+ej6fdFZ$dddBdEeej6d5ej6dCe ej6d+ej6fdGZ%ddddHdEeej6d5ej6dIe dCe ej6d+ej6f dJZ&dWdKZ'dLZ( dXd@ej6dMee ej6fd5ej6dNed+ee)e*ff dOZ+d5ej6d+ej6fdPZ,dQej6dCej6d3ejZd+ej6fdRZ.dSZ/ycc}}w)YDPMSolverSinglestepScheduleru `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$|jjrts tdt |jj|jj |jj gdkDr td| dk(rd}tdd||+tj|tj|_ n|d k(r-tj|||tj|_ nk|d k(r6tj|d z|d z|tjd z|_ n0|d k(rt||_ nt|d|j d|jz |_tj$|j"d|_tj(|j&|_tj(d|j&z |_tj.|j*tj.|j,z |_d|j&z |j&z d z|_d|_| dvr2| dk(r|j7dnt| d|j | dvr1| dvr|j7dnt| d|j | dvr|dk(rtd|d| dd|_t;jd|dz |t:jdddj=}tj>||_ dg|z|_!d|_"|jG||_$d|_%d|_&|j2jOd |_y)!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.0rr2 scaled_linear?rsquaredcos_cap_v2z is not implemented for r4rdim)rRr5sde-dpmsolver++deisr5)rD)r6heun)logrhobh1bh2r6)rEr5rYr7z`final_sigmas_type` z' is not supported for `algorithm_type` z$. Please choose `sigma_min` instead.cpu)(configrIr ImportErrorsumrHrGr!r r%r&r'r+linspacer/NotImplementedError __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>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPdeprecation_messagervs r__init__z%DPMSolverSinglestepScheduler.__init__sF6 ;; & &/A/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)rrrrrr7r`)rbr?r!rFrL)r~rrstepsorderorderss rryz+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 rc|jS)zg The index counter for current timestep. It will increase 1 after each scheduler step. )r{r~s 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. r|rs r begin_indexz(DPMSolverSinglestepScheduler.begin_indexs    rrc||_y)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)r~rs rset_begin_indexz,DPMSolverSinglestepScheduler.set_begin_index$s (rdevicemurvc (|U|jjr|jjdk(sJtj||j_| | t d| | t d|!|jjr t d|!|jjr t d|!|jjr t d|xs t|}||_ |3tj|jtj}ntj tj"|j$dg|jj&}|j)}tj*d|jj,dz |z |dzj/ddd dd j1jtj}tjd|j2z |j2z d z}tj4|}|jjrytj"|j1}|j7|| }tj|Dcgc]}|j9||c}j/}n|jjrktj"|j1}|j;|| }tj|Dcgc]}|j9||c}}n|jjrktj"|j1}|j=|| }tj|Dcgc]}|j9||c}}n|jj>rtj*dd|jj,z |dz} d | z }tj"|jj |zd|jj dz |zzz dd j1}||jj,zj1}n4tj@|tjBdt||}|jjDd k(r&d|j2dz |j2dz d z} n>|jjDdk(rd} n"t d|jjDtjF|| ggjtjH}tjJ|jM||_'tjJ|jM|tj|_(dg|jjRz|_*d|_+|jjXsC||jjRzdk7r'tZj]d|j_d|jjXs@|jjDdk(r'tZj]d|j_d|ja||_1d|_2d|_3|jNjMd|_'ycc}wcc}wcc}w)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`. Nr9z?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,,vSf,gFSY!Z%$"2"25*"E!Z[aacI [[ / /WWV_))+F11FXk1lFSY!Z%$"2"25*"E!Z[I [[ ( (WWV_))+F**VQd*eFSY!Z%$"2"25*"E!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&>&>> {{,,1Dt{{G_G_1_cd1d NNs   # #d # ;{{,,1N1NRX1X NNg   # #d # ;--.AB  kknnU+ e"["["[s\.\ /\rxcb|j}|j^}}}|tjtjfvr|j }|j ||tj|z}|j}tj||jjd}tj|d|jj}|jd}tj|| ||z }|j ||g|}|j!|}|S)a{ "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 rrW)r$max)r shaper%r'float64floatreshapersprodabsquantilerbrBclamprC unsqueezer})r~rxr batch_sizechannelsremaining_dims abs_sampless r_threshold_samplez.DPMSolverSinglestepScheduler._threshold_samples 06 - H~  6 6\\^F Hrww~7N,NOZZ\ NN:t{{'M'MST U KK 1$++66  KKNVaR+a/ HF~F5! rctjtj|d}||ddtjfz }tj|dk\dj dj |jddz }|dz}||}||}||z ||z z } tj | dd} d| z |z| |zz} | j|j} | S)Ng|=r)axisr)rr) rsrnmaximumnewaxiscumsumargmaxcliprr) r~rr log_sigmadistslow_idxhigh_idxlowhighwrs rrz(DPMSolverSinglestepScheduler._sigma_to_tsFF2::eU34 Jq"**}55))UaZq188a8@EE*JZJZ[\J]`aJaEbQ;!(#9_t , GGAq! Ug H , IIekk "rcr|jjr d|z }|}||fSd|dzdzdzz }||z}||fS)NrrrU)rbrJ)r~rrlrms r_sigma_to_alpha_sigma_tz4DPMSolverSinglestepScheduler._sigma_to_alpha_sigma_tsW ;; & &%iGG E1HqLS01GgoGrrct|jdr|jj}nd}t|jdr|jj}nd}||n|dj }||n|dj }d}t j dd|}|d|z z}|d|z z}||||z zz|z} | S)z6Constructs the noise schedule of Karras et al. (2022).rN sigma_maxr`rg@r)hasattrrbrrrrsre) r~rrrrrrhoramp min_inv_rho max_inv_rhorps rrz/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 argumentrvrSPassing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`r_r3)learned learned_rangerrx v_predictionflow_predictionzprediction_type given as zo must be one of `epsilon`, `sample`, `v_prediction`, or `flow_prediction` for the DPMSolverSinglestepScheduler.rRz\ must be one of `epsilon`, `sample`, or `v_prediction` for the DPMSolverSinglestepScheduler.)rpopr!r rbrDr@rNrprrrArrlrm) r~rrxargskwargsrrrlrmx0_predr3s rconvert_model_outputz1DPMSolverSinglestepScheduler.convert_model_output/sT:"$i!m47J1M >4y1}a !RSS   Z  ;; % %)K K{{**i7;;,,0LL#/2A2#6L DOO4#'#?#?#F !Gl$::gE,,8&,,> DOO4#'#?#?#F !F*W|-CC,,0AA++doo6 7\#99 / 0K0K/LMaa {{''009N[[ ' '; 6{{**i7;;,,0LL*1bqb51G*G,,8 DOO4#'#?#?#F !Gl$::gE,,> DOO4#'#?#?#F !L07V3CC / 0K0K/LMLL {{''#'<<#94<<;Q!Gg$55@009!Gg$55@N77rrxnoiserc t|dkDr|dn|jdd}t|dkDr|dn|jdd}|t|dkDr|d}n td| tdd d | tdd d |j|j dz|j|j } }|j |\} }|j | \} } tj| tj|z } tj| tj| z } | | z }|jjd k(r*|| z |z| tj| d z z|zz }|S|jjdk(r)| | z |z|tj|d z z|zz }|S|jjdk(rz|J|| z tj| z|z| dtjd|zz z|zz|tjd tjd|zz 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_timesteprrrvrSrPassing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`r5r4rRrY) rrr!r rprrr%rnrbrDrrk)r~rrxrrrrrrmsigma_srlalpha_srolambda_shx_ts rdpm_solver_first_order_updatez:DPMSolverSinglestepScheduler.dpm_solver_first_order_updates`2"$i!m47J1M#&t9q=QfjjRV6W >4y1}a !RSS   Z   $ ^   ;;t':;T[[=Y77@77@99W% '(::99W% '(:: x  ;; % % 6W$.'UYYr]S=P2QUa1aaC [[ ' '; 6W$.'UYYq\C=O2PT`1``C [[ ' '+< <$ $$7"UYYr]2f<a%))D1H"556,FGEJJsUYYrAv->'>??%GH   rmodel_output_listc 4 t|dkDr|dn|jdd}t|dkDr|dn|jdd}|t|dkDr|d}n td| tddd | tddd |j|j dz|j|j |j|j dz } } }|j |\} }|j | \} } |j | \} } tj| tj|z }tj| tj| z }tj| tj| z }|d |d }}||z ||z }}||z }|d |z ||z z}}|jjdk(r|jjdk(rM|| z |z| tj| d z z|zz d| tj| d z zz|zz }|S|jjdk(rN|| z |z| tj| d z z|zz | tj| d z |z d zz|zz}S|jjdk(r|jjdk(rK| | z |z|tj|d z z|zz d|tj|d z zz|zz }|S|jjdk(rL| | z |z|tj|d z z|zz |tj|d z |z d z z|zz }S|jjdk(rt|J|jjdk(r|| z tj| z|z| dtjd|zz z|zzd| dtjd|zz zz|zz|tjd tjd |zz z|zz}|S|jjdk(r|| z tj| z|z| dtjd|zz z|zz| d tjd|zz d|zz d zz|zz|tjd tjd |zz 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_listNrrrrrSPassing `timestep_list` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`rr`rr4r5r6rUr[rRrYrrrr!r rprrr%rnrbrDrErrk)r~rrxrrrrrrmsigma_s0sigma_s1rlalpha_s0alpha_s1ro lambda_s0 lambda_s1m0m1rh_0r0D0D1rs r)singlestep_dpm_solver_second_order_updatezFDPMSolverSinglestepScheduler.singlestep_dpm_solver_second_order_updates[4$'t9q=QfjjRV6W #&t9q=QfjjRV6W >4y1}a !RSS  $ ^   $ ^  KK!+ , KK ( KK!+ ,$  77@!99(C(!99(C(99W% '(::IIh'%))H*== IIh'%))H*== "2&(9"(=BI%y9'<3 1WcBh27+B ;; % % 6{{&&*4x'61%))QB-#"56"<=W 1" (;<=BCR I((F2x'61%))QB-#"56"<=599aR=3#6!";c"ABbHIF =[[ ' '; 6{{&&*4x'61%))A,"45;<W ! s(:;4y1}a !RSS  $ ^   $ ^  KK!+ , KK ( KK!+ , KK!+ , 1 -8X 77@!99(C(!99(C(!99(C(99W% '(::IIh'%))H*== IIh'%))H*== IIh'%))H*== &r*,=b,ACTUWCXB*I ,A9yCX3q#'B Bh27+cBh27-Cd4i"t)#R 0 D4K BG , ;; % % 6{{&&*4x'61%))QB-#"56"<=599aR=3#6!";c"ABdJKX O((F2x'61%))QB-#"56"<=599aR=3#6!";c"ABbHI599aR=3#6#:ad"BS"HIROPL A[[ ' '; 6{{&&*4x'61%))A,"45;<599Q<##5":S"@ATIJ: 1((F2x'61%))A,"45;<599Q<##5":S"@ARGH599Q<##5#9QT"AC"GHBNO. #[[ ' '+< <$ $${{&&*4x'%))QB-76A# $((;";<BC34!8)<#<"JS"PQUYYZ 3261B+B CCeKL ((F2x'%))QB-76A# $((;";<BC34!8)<#<"JS"PQUWWX34!8)<#<q#IdUVh[\_"\_b"bcgiij 3261B+B CCeK L rrxrrrct|dkDr|dn|jdd}t|dkDr|dn|jdd}|t|dkDr|d}n td|t|dkDr|d}n td | tdd d | tdd d |dk(r|j |d ||S|dk(r|j |||S|dk(r|j |||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. rrNrrrrrz.missing `order` as a required keyword argumentrSrrr`rzOrder must be 1, 2, 3, got )rrr!r rrr) r~rrxrrrrrrs rsinglestep_dpm_solver_updatez9DPMSolverSinglestepScheduler.singlestep_dpm_solver_updatesF8$'t9q=QfjjRV6W #&t9q=QfjjRV6W >4y1}a !RSS =4y1}Q !QRR  $ ^   $ ^  A:556G6KTZbg5h h aZAABS\bjoAp p aZ@@AR[ain@o o:5'BC Crc| |j}||k(j}t|dk(rt|jdz }|St|dkDr|dj}|S|dj}|S)Nrr)rvnonzerorr)r~rschedule_timestepsindex_candidatesrs rindex_for_timestepz/DPMSolverSinglestepScheduler.index_for_timesteps  %!% .(:CCE  A %T^^,q0J ! "Q &)!,113J*!,113Jrc|jVt|tjr%|j |j j }|j||_y|j|_y)zF Initialize the step_index counter for the scheduler. N) r isinstancer%Tensorr}rvrrr{r|)r~rs r_init_step_indexz-DPMSolverSinglestepScheduler._init_step_indexsW    #(ELL1#;;t~~'<'<=#66x@D #00D rr return_dictc|j td|j|j||j ||}t |j jdz D]!}|j|dz|j|<#||jd<|j jdk(r.t|j||j|j}nd}|j|j}|j| |dz}|j| |dk(r||_|j!|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 schedulerrrr`rY) generatorrr r) prev_sample)rrr!rrrr"rbr?rwrDr rrr rzrxrr{r) r~rrrxr"r r,rrr#s rstepz!DPMSolverSinglestepScheduler.steps8  # # +s  ?? "  ! !( +00f0M t{{//!34 >A$($6$6q1u$=D  q ! >!-2 ;; % %): : ""i @S@S[g[m[mEE0  %(0 QJE  %(0 A: DK77   t{{%u8 A> !;77rc|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. )r~rxrrs rscale_model_inputz.DPMSolverSinglestepScheduler.scale_model_inputcs  roriginal_samplesc*|jj|j|j}|jjdk(rvt j |ra|jj|jt j}|j|jt j}n@|jj|j}|j|j}|j |Dcgc]}|j||}}nG|j|jg|jdz}n|jg|jdz}||j}t|jt|jkr=|jd}t|jt|jkr=|j!|\} } | |z| |zz} | Scc}w)Nrmpsrrr`)rpr}rr typer%is_floating_pointrvr'rrrrflattenrrr) r~r(rrvrprr step_indicesrrlrm noisy_sampless r add_noisez&DPMSolverSinglestepScheduler.add_noisess'7'>'>FVF\F\]  " " ' '5 0U5L5LY5W!%!2!23C3J3JRWR_R_!2!` ! %5%<%"22Wu_D _sHc.|jjSN)rbr:rs r__len__z$DPMSolverSinglestepScheduler.__len__s{{...r)r)NNNN)333333?r4r2)NT)0__name__ __module__ __qualname____doc__rname _compatiblesrr rintstrrrsndarrayboolrrrypropertyrrrrr%rrrrrrrrrrrrrrrrrrr$r' IntTensorr0r3).0es00rr1r1PsI>@%>>qAFF>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 ?sLr1)g+?r)rtypingrrrrnumpyrsr%configuration_utilsrr utilsr r r utils.torch_utilsr scheduling_utilsrrr scipy.statsr get_loggerr5rr/r1r&rrrKsc" // A::,XX   H % !)4XF/>;F/r