i+ ddlZddlmZmZmZmZmZddlZddl Z ddl m Z m Z ddl mZmZmZddlmZddlmZmZmZerddlZej2eZ dd ed ed ed d e j<fdZGddee Z y)N)ListLiteralOptionalTupleUnion) ConfigMixinregister_to_config) deprecateis_scipy_availablelogging) randn_tensor)KarrasDiffusionSchedulersSchedulerMixinSchedulerOutputnum_diffusion_timestepsmax_betaalpha_transform_type)cosineexpreturnc $|dk(rd}n|dk(rd}ntd|g}t|D]<}||z }|dz|z }|jtd||||z z |>t j |tj S)aB 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 (`"cosine"` or `"exp"`, defaults to `"cosine"`): The type of noise schedule for `alpha_bar`. Choose from `cosine` or `exp`. Returns: `torch.Tensor`: The betas used by the scheduler to step the model outputs. rcftj|dzdz tjzdz dzS)NgMb?gT㥛 ?r)mathcospits ~/home/obispo/Crisostomo_bridge/mision_env/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 Crc2tj|dzS)Ng()rrrs r r!z)betas_for_alpha_bar..alpha_bar_fnCs88AI& &r"z"Unsupported alpha_transform_type: rdtype) ValueErrorrangeappendmintorchtensorfloat32)rrrr!betasit1t2s r betas_for_alpha_barr1$s0x' D  & '=>R=STUU E * +M ( (!e. . S\"- R0@@@(KLM <<U]] 33r"c0eZdZdZeDcgc]}|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.ZdUd/e fd0Z dVd*e d1ee ej2fd2e e d3e ee fd4Zd5ej6d+ej6fd6Zd7Zd8Zd9ej6d+ej6fd:Zd9ej6d*e d+ej6fd;Z dWd9ej6d*e dZ!dd?d@ej6d5ej6d+ej6fdAZ"dddBd@ej6d5ej6dCe ej6d+ej6fdDZ#dddBdEeej6d5ej6dCe ej6d+ej6fdFZ$dddBdEeej6d5ej6dCe ej6d+ej6fdGZ%ddddHdEeej6d5ej6dIe dCe ej6d+ej6f dJZ& dXdKee ej6fdLe ej6d+e fdMZ'dNZ( dYd@ej6dKee ej6fd5ej6dOed+ee)e*ff dPZ+d5ej6d+ej6fdQZ,dRej6dCej6d3ejZd+ej6fdSZ.dTZ/ycc}}w)ZDPMSolverSinglestepScheduleru `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://huggingface.co/papers/2210.02303) 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.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-linspacer1NotImplementedError __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__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)rrrrrr9rb)rdrAr&rHrN)rrtstepsorderorderss r r{z+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"c|jS)zg The index counter for current timestep. It will increase 1 after each scheduler step. )r}rs r step_indexz'DPMSolverSinglestepScheduler.step_indexs r"c|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    r"rc||_y)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 r set_begin_indexz,DPMSolverSinglestepScheduler.set_begin_index%s (r"devicemurxc (|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`. 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,,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\.\ /\rzcb|j}|j^}}}|tjtjfvr|j }|j ||tj|z}|j}tj||jjd}tj|d|jj}|jd}tj|| ||z }|j ||g|}|j!|}|S)az 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. rrY)r)max)r%shaper*r,float64floatreshaperuprodabsquantilerdrDclamprE unsqueezer)rrzr% 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! r"ctjtj|d}||ddtjfz }tj|dk\dj dj |jddz }|dz}||}||}||z ||z z } tj | dd} d| z |z| |zz} | j|j} | S)a 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) rurpmaximumnewaxiscumsumargmaxcliprr) rrr log_sigmadistslow_idxhigh_idxlowhighwrs r rz(DPMSolverSinglestepScheduler._sigma_to_tsFF2::eU34 Jq"**}55))UaZq188a8@EE*JZJZ[\J]`aJaEbQ;!(#9_t , GGAq! Ug H , IIekk "r"cr|jjr d|z }|}||fSd|dzdzdzz }||z}||fS)a( 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. rrrW)rdrL)rrrnros r _sigma_to_alpha_sigma_tz4DPMSolverSinglestepScheduler._sigma_to_alpha_sigma_tsY ;; & &%iGG E1HqLS01GgoGr"rct|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)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. rN sigma_maxrbrg@r)hasattrrdrrrrurg) rrrtrrrhoramp min_inv_rho max_inv_rhorrs r rz/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 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 r convert_model_outputz1DPMSolverSinglestepScheduler.convert_model_output|sT2"$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@N77r"rznoiserc 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_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 r dpm_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   r"model_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_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_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 r"rzrrrct|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 argumentrUrrrbrzOrder must be 1, 2, 3, got )rrr&r rrr) rrrzrrrrrrs r singlestep_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 Cr"rschedule_timestepsc| |j}||k(j}t|dk(rt|jdz }|St|dkDr|dj}|S|dj}|S)a 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)rxnonzerorr)rrrindex_candidatesrs r index_for_timestepz/DPMSolverSinglestepScheduler.index_for_timestepEs  %!% .(:CCE  A %T^^,q0J ! "Q &)!,113J*!,113Jr"c|jVt|tjr%|j |j j }|j||_y|j|_y)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 isinstancer*Tensorrrxrrr}r~)rrs r _init_step_indexz-DPMSolverSinglestepScheduler._init_step_indexhsW    #(ELL1#;;t~~'<'<=#66x@D #00D r" 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 schedulerrrrbr[) generatorrr%r) prev_sample)rtr&rr rr'rdrAryrFrrrr%r|rzrr}r) rrrrzr#r!r.rrr$s r stepz!DPMSolverSinglestepScheduler.stepxs8  # # +s  ?? "  ! !( +00f0M t{{//!34 >A$($6$6q1u$=D  q ! >!-2 ;; % %): : ""i @S@S[g[m[mEE0  %(0 QJE  %(0 A: DK77   t{{%u8 A> !;77r"c|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. )rrzrrs r scale_model_inputz.DPMSolverSinglestepScheduler.scale_model_inputs  r"original_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)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$rrb)rrrrr%typer*is_floating_pointrxr,rrrrflattenrrr) rr)rrxrrrr step_indicesrrnro noisy_sampless r add_noisez&DPMSolverSinglestepScheduler.add_noises,'7'>'>FVF\F\]  " " ' '5 0U5L5LY5W!%!2!23C3J3JRWR_R_!2!` ! %5%<%"22Wu_D _sHc.|jjSN)rdr<rs r __len__z$DPMSolverSinglestepScheduler.__len__s{{...r")r)NNNN)333333?r5r3)NT)0__name__ __module__ __qualname____doc__rname _compatiblesrr rintstrrrundarrayboolrrr{propertyrrrrr*rrrrrrrrrrrrrrrr rrr%r( IntTensorr1r4).0es00r r3r3Qs>@%>>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) ))X"J ,$ELL$RWR^R^$NTW\a\h\hFdg..ll> >  % > >H $(, m -m m  % m mf $(, x -x x  % x x| $(, =D -=D =D  =D  % =D =DB`d c5<</0 FNu||F\   F1* E8llE8U\\)*E8 E8  E8 % &E8N  %,,  /,,/||/?? /  /b/]#?sMr3)g+?r)!rtypingrrrrrnumpyrur*configuration_utilsr r utilsr r r utils.torch_utilsrscheduling_utilsrrr scipy.statsr get_loggerr6rr<rrr1r3r'r"r rLs" 88 A::,XX   H % 5=*4 *4*4"/2*4 \\ *4Zp/>;p/r"