
    +h3s                        S SK r S SKJr  S SKJrJrJrJr  S SKr	S SK
r
S SKrSSKJrJr  SSKJrJr  SSKJrJr  \" 5       (       a  S SKr\ " S	 S
\5      5       r " S S5      r " S S5      r  SS jr " S S\\5      rg)    N)	dataclass)ListOptionalTupleUnion   )ConfigMixinregister_to_config)
BaseOutputis_scipy_available   )KarrasDiffusionSchedulersSchedulerMixinc                   `    \ rS rSr% Sr\R                  \S'   Sr\	\R                     \S'   Sr
g)DPMSolverSDESchedulerOutput    aM  
Output class for the scheduler's `step` function output.

Args:
    prev_sample (`torch.Tensor` of shape `(batch_size, num_channels, height, width)` for images):
        Computed sample `(x_{t-1})` of previous timestep. `prev_sample` should be used as next model input in the
        denoising loop.
    pred_original_sample (`torch.Tensor` of shape `(batch_size, num_channels, height, width)` for images):
        The predicted denoised sample `(x_{0})` based on the model output from the current timestep.
        `pred_original_sample` can be used to preview progress or for guidance.
prev_sampleNpred_original_sample )__name__
__module____qualname____firstlineno____doc__torchTensor__annotations__r   r   __static_attributes__r       g/home/james-whalen/.local/lib/python3.13/site-packages/diffusers/schedulers/scheduling_dpmsolver_sde.pyr   r       s'    
 37(5<<07r   r   c                   8    \ rS rSrSrSS jr\S 5       rS rSr	g)	BatchedBrownianTree3   zGA wrapper around torchsde.BrownianTree that enables batches of entropy.Nc                    U R                  X#5      u  p#U l        UR                  S[        R                  " U5      5      nUc&  [        R
                  " SS/ 5      R                  5       nSU l         [        U5      UR                  S   :X  d   eUS   nU Vs/ s H=  n[        R                  " UUUR                  UR                  UR                  USSSS9	PM?     snU l        g ! [         a    U/nSU l         Ngf = fs  snf )	Nw0r   l    TFgư>   )	t0t1sizedtypedeviceentropytol	pool_sizehalfway_tree)sortsigngetr   
zeros_likerandintitembatchedlenshape	TypeErrortorchsdeBrownianIntervalr*   r+   trees)selfxr'   r(   seedkwargsr%   ss           r    __init__BatchedBrownianTree.__init__6   s     IIb-	ZZe..q12<==Ir2779D	!t9
***AB  
  %%XXhhyy!
 

  	!6D DL	!
s   1#C% AC?%C<;C<c                     X:  a  XS4$ XS4$ )Nr   r   )abs     r    r0   BatchedBrownianTree.sortQ   s    Eay1bz1r   c           	          U R                  X5      u  pn[        R                  " U R                   Vs/ s H
  oD" X5      PM     sn5      U R                  U-  -  nU R
                  (       a  U$ US   $ s  snf )Nr   )r0   r   stackr<   r1   r6   )r=   r'   r(   r1   treews         r    __call__BatchedBrownianTree.__call__U   sa    yy(KK$**=*$b*=>$))dBRSLLq*ad* >s   A3)r6   r1   r<   N)
r   r   r   r   r   rB   staticmethodr0   rM   r   r   r   r    r"   r"   3   s#    Q
6 2 2+r   r"   c                   .    \ rS rSrSrSS 4S jrS rSrg)BrownianTreeNoiseSampler[   aG  A noise sampler backed by a torchsde.BrownianTree.

Args:
    x (Tensor): The tensor whose shape, device and dtype to use to generate
        random samples.
    sigma_min (float): The low end of the valid interval.
    sigma_max (float): The high end of the valid interval.
    seed (int or List[int]): The random seed. If a list of seeds is
        supplied instead of a single integer, then the noise sampler will use one BrownianTree per batch item, each
        with its own seed.
    transform (callable): A function that maps sigma to the sampler's
        internal timestep.
Nc                     U $ rO   r   )r>   s    r    <lambda>!BrownianTreeNoiseSampler.<lambda>j   s    qr   c                     XPl         U R                  [        R                  " U5      5      U R                  [        R                  " U5      5      pv[        XXt5      U l        g rO   )	transformr   	as_tensorr"   rK   )r=   r>   	sigma_min	sigma_maxr?   rX   r'   r(   s           r    rB   !BrownianTreeNoiseSampler.__init__j   sA    "	 :;T^^EOO\eLf=gB'r8	r   c                     U R                  [        R                  " U5      5      U R                  [        R                  " U5      5      pCU R                  X45      XC-
  R	                  5       R                  5       -  $ rO   )rX   r   rY   rK   abssqrt)r=   sigma
sigma_nextr'   r(   s        r    rM   !BrownianTreeNoiseSampler.__call__o   sS     67XbHc9dByy BG==?#7#7#999r   )rX   rK   )r   r   r   r   r   rB   rM   r   r   r   r    rR   rR   [   s     6:[ 9
:r   rR   c           
      &   US:X  a  S nOUS:X  a  S nO[        SU 35      e/ n[        U 5       H<  nXP-  nUS-   U -  nUR                  [        SU" U5      U" U5      -  -
  U5      5        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`): 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
cosinec                 h    [         R                  " U S-   S-  [         R                  -  S-  5      S-  $ )NgMb?gT㥛 ?r   )mathcospits    r    alpha_bar_fn)betas_for_alpha_bar.<locals>.alpha_bar_fn   s-    88QY%/$''9A=>!CCr   expc                 4    [         R                  " U S-  5      $ )Ng      ()rf   rm   ri   s    r    rk   rl      s    88AI&&r   z"Unsupported alpha_transform_type: r   r*   )
ValueErrorrangeappendminr   tensorfloat32)num_diffusion_timestepsmax_betaalpha_transform_typerk   betasir(   t2s           r    betas_for_alpha_barr|   u   s    . x'	D 
	&	' =>R=STUUE*+(!e..S\"-R0@@@(KL , <<U]]33r   c                      \ rS rSrSr\ V Vs/ s H  oR                  PM     snn rSr\	            S3S\
S\S\S\S	\\\R                   \\   4      S
\S\\   S\\   S\\   S\\
   S\S\
4S jj5       rS4S jrS r\S 5       r\S 5       r\S 5       rS5S\
4S jjrS\R8                  S\\\R8                  4   S\R8                  4S jr  S6S\
S\\\R<                  4   S\\
   4S jjrS  r S! r!S"\R8                  S\R8                  4S# jr"S"\R8                  S\
S\R8                  4S$ jr# S7S"\R8                  S\
S%\S&\S\R8                  4
S' jjr$\S( 5       r%  S8S)\\R8                  \R                   4   S\\\R8                  4   S\\R8                  \R                   4   S*\S+\S\\&\'4   4S, jjr(S-\R8                  S.\R8                  S/\R8                  S\R8                  4S0 jr)S1 r*S2r+gs  snn f )9DPMSolverSDEScheduler   u=
  
DPMSolverSDEScheduler implements the stochastic sampler from the [Elucidating the Design Space of Diffusion-Based
Generative Models](https://huggingface.co/papers/2206.00364) paper.

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.00085):
        The starting `beta` value of inference.
    beta_end (`float`, defaults to 0.012):
        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` or `scaled_linear`.
    trained_betas (`np.ndarray`, *optional*):
        Pass an array of betas directly to the constructor to bypass `beta_start` and `beta_end`.
    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).
    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.
    noise_sampler_seed (`int`, *optional*, defaults to `None`):
        The random seed to use for the noise sampler. If `None`, a random seed is generated.
    timestep_spacing (`str`, defaults to `"linspace"`):
        The way the timesteps should be scaled. Refer to Table 2 of the [Common Diffusion Noise Schedules and
        Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) for more information.
    steps_offset (`int`, defaults to 0):
        An offset added to the inference steps, as required by some model families.
r   Nnum_train_timesteps
beta_startbeta_endbeta_scheduletrained_betasprediction_typeuse_karras_sigmasuse_exponential_sigmasuse_beta_sigmasnoise_sampler_seedtimestep_spacingsteps_offsetc                    U R                   R                  (       a  [        5       (       d  [        S5      e[	        U R                   R                  U R                   R
                  U R                   R                  /5      S:  a  [        S5      eUb)  [        R                  " U[        R                  S9U l        OUS:X  a*  [        R                  " X#U[        R                  S9U l        OkUS:X  a4  [        R                  " US-  US-  U[        R                  S9S-  U l        O1US	:X  a  [        U5      U l        O[        U S
U R                   35      eSU R                  -
  U l        [        R"                  " U R                   SS9U l        U R'                  US U5        Xpl        S U l        Xl        S U l        S U l        U R0                  R3                  S5      U l        g )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.ro   linearscaled_linear      ?r   squaredcos_cap_v2z is not implemented for       ?r   )dimcpu)configr   r   ImportErrorsumr   r   rp   r   rt   ru   ry   linspacer|   NotImplementedError	__class__alphascumprodalphas_cumprodset_timestepsnoise_samplerr   _step_index_begin_indexsigmasto)r=   r   r   r   r   r   r   r   r   r   r   r   r   s                r    rB   DPMSolverSDEScheduler.__init__   s     ;;&&/A/C/CZ[[++T[[-O-OQUQ\Q\QnQnopstt A  $m5==IDJh&
>QY^YfYfgDJo-
C3H[chcpcpquvvDJ11,-@ADJ%7OPTP^P^O_&`aaDJJ&#mmDKKQ? 	.6IJ!2!"4 kknnU+r   c                     Uc  U R                   nX!:H  R                  5       n[        U5      S:  a  SOSnX4   R                  5       $ )Nr   r   )	timestepsnonzeror7   r5   )r=   timestepschedule_timestepsindicesposs        r    index_for_timestep(DPMSolverSDEScheduler.index_for_timestep   sH    %!%%1::< w<!#a|  ""r   c                     U R                   c[  [        U[        R                  5      (       a%  UR	                  U R
                  R                  5      nU R                  U5      U l        g U R                  U l        g rO   )
begin_index
isinstancer   r   r   r   r+   r   r   r   )r=   r   s     r    _init_step_index&DPMSolverSDEScheduler._init_step_index  sX    #(ELL11#;;t~~'<'<=#66x@D#00Dr   c                     U R                   R                  S;   a  U R                  R                  5       $ U R                  R                  5       S-  S-   S-  $ )N)r   trailingr   r   r   )r   r   r   maxr=   s    r    init_noise_sigma&DPMSolverSDEScheduler.init_noise_sigma  sH     ;;''+CC;;??$$!Q&*s22r   c                     U R                   $ )zW
The index counter for current timestep. It will increase 1 after each scheduler step.
)r   r   s    r    
step_index DPMSolverSDEScheduler.step_index  s    
 r   c                     U R                   $ )za
The index for the first timestep. It should be set from pipeline with `set_begin_index` method.
r   r   s    r    r   !DPMSolverSDEScheduler.begin_index#  s    
    r   r   c                     Xl         g)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=   r   s     r    set_begin_index%DPMSolverSDEScheduler.set_begin_index+  s
     (r   sampler   returnc                     U R                   c  U R                  U5        U R                  U R                      nU R                  (       a  UOU R                  nXS-  S-   S-  -  nU$ )aN  
Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.

Args:
    sample (`torch.Tensor`):
        The input sample.
    timestep (`int`, *optional*):
        The current timestep in the diffusion chain.

Returns:
    `torch.Tensor`:
        A scaled input sample.
r   r   r   )r   r   r   state_in_first_ordermid_point_sigma)r=   r   r   r`   sigma_inputs        r    scale_model_input'DPMSolverSDEScheduler.scale_model_input5  s^    & ??"!!(+DOO,#88ed>R>RNQ.367r   num_inference_stepsr+   c           	      	   Xl         U=(       d    U R                  R                  nU R                  R                  S:X  a4  [        R
                  " SUS-
  U[        S9SSS2   R                  5       nGO(U R                  R                  S:X  av  X0R                   -  n[        R                  " SU5      U-  R                  5       SSS2   R                  5       R                  [        5      nX@R                  R                  -  nOU R                  R                  S:X  a\  X0R                   -  n[        R                  " USU* 5      R                  5       R                  5       R                  [        5      nUS-  nO"[        U R                  R                   S	35      e[        R                  " SU R                  -
  U R                  -  S
-  5      n[        R                  " U5      n[        R                   " U[        R                  " S[#        U5      5      U5      nU R                  R$                  (       aE  U R'                  US9n[        R                  " U Vs/ s H  oR)                  X5      PM     sn5      nOU R                  R*                  (       aE  U R-                  XaS9n[        R                  " U Vs/ s H  oR)                  X5      PM     sn5      nO_U R                  R.                  (       aD  U R1                  XaS9n[        R                  " U Vs/ s H  oR)                  X5      PM     sn5      nU R3                  Xg5      n	[        R4                  " US//5      R                  [        R6                  5      n[8        R:                  " U5      R=                  US9n[8        R>                  " USS USS RA                  S5      USS /5      U l!        [8        R:                  " U5      n[8        R:                  " U	5      n	[8        R>                  " USS USS RA                  S5      /5      nXSSS2'   [E        U5      RG                  S5      (       a$  UR=                  U[8        R6                  S9U l$        OUR=                  US9U l$        SU l%        SU l&        SU l'        SU l(        U RB                  R=                  S5      U l!        SU l)        gs  snf s  snf s  snf )au  
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.
r   r   r   ro   NrE   leadingr   zY is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'.r   )	in_sigmas)r   r   g        )r+   r   mpsr   )*r   r   r   r   npr   floatcopyarangeroundastyper   rp   arrayr   loginterpr7   r   _convert_to_karras_sigma_to_tr   _convert_to_exponentialr   _convert_to_beta_second_order_timestepsconcatenateru   r   
from_numpyr   catrepeat_interleaver   str
startswithr   r   r   r   r   r   )
r=   r   r+   r   r   
step_ratior   
log_sigmasr`   second_order_timestepss
             r    r   #DPMSolverSDEScheduler.set_timestepsP  s    $7 1TT[[5T5T ;;'':5A':Q'>@S[`abfdfbfgllnI[[))Y6,0H0HHJ 1&9:ZGNNPQUSUQUV[[]ddejkI111I[[))Z7,/G/GGJ #6J;GNNPUUW^^_deINI;;//0  1J  K  A 3 33t7J7JJsRSVVF^
9bii3v;&?H;;((,,v,>FSY!ZSY%"2"25"ESY!Z[I[[//11F1lFSY!ZSY%"2"25"ESY!Z[I[[((**V*eFSY!ZSY%"2"25"ESY!Z[I!%!=!=f!Q#077

C!!&),,F,;iiVAb\-K-KA-NPVWYWZP[ \]$$Y/	!&!1!12H!IIIy!}im.M.Ma.PQR	0!$Q$v;!!%((&\\&\FDN&\\\8DN # kknnU+!A "[ "[ "[s   S9SSc           	          S nS nSnU" U5      n[         R                  " U5      nUS S Xu-  -   nU" U5      n	[         R                  " U	 V
s/ s H  oR                  X5      PM     sn
5      nU$ s  sn
f )Nc                 0    [         R                  " U * 5      $ rO   )r   rm   _ts    r    sigma_fn?DPMSolverSDEScheduler._second_order_timesteps.<locals>.sigma_fn  s    662#;r   c                 0    [         R                  " U 5      * $ rO   )r   r   _sigmas    r    t_fn;DPMSolverSDEScheduler._second_order_timesteps.<locals>.t_fn  s    FF6N?"r   r   rE   )r   diffr   r   )r=   r   r   r   r   midpoint_ratiorj   
delta_time
t_proposedsig_proposedr`   r   s               r    r   -DPMSolverSDEScheduler._second_order_timesteps  sx    		# LWWQZ
sVj99

+HH|\|e..uA|\]	 ]s   A0c                    [         R                  " [         R                  " US5      5      nX2S S 2[         R                  4   -
  n[         R                  " US:  SS9R                  SS9R                  UR                  S   S-
  S9nUS-   nX%   nX&   nXs-
  Xx-
  -  n	[         R                  " U	SS5      n	SU	-
  U-  X-  -   n
U
R                  UR                  5      n
U
$ )Ng|=r   )axisr   )r   r   )	r   r   maximumnewaxiscumsumargmaxclipr8   reshape)r=   r`   r   	log_sigmadistslow_idxhigh_idxlowhighrL   rj   s              r    r   !DPMSolverSDEScheduler._sigma_to_t  s    FF2::eU34	 q"**}55 ))UaZq188a8@EE*JZJZ[\J]`aJaEbQ;!# _,GGAq! Ug,IIekk"r   r   c                     US   R                  5       nUS   R                  5       nSn[        R                  " SSU R                  5      nUSU-  -  nUSU-  -  nXuXg-
  -  -   U-  nU$ )z6Constructs the noise schedule of Karras et al. (2022).rE   r   g      @r   )r5   r   r   r   )	r=   r   rZ   r[   rhorampmin_inv_rhomax_inv_rhor   s	            r    r   (DPMSolverSDEScheduler._convert_to_karras  s{     %R=--/	$Q<,,.	{{1a!9!9:AG,AG,(A BBsJr   c                    [        U R                  S5      (       a  U R                  R                  nOSn[        U R                  S5      (       a  U R                  R                  nOSnUb  UOUS   R	                  5       nUb  UOUS   R	                  5       n[
        R                  " [
        R                  " [        R                  " U5      [        R                  " U5      U5      5      nU$ )z)Constructs an exponential noise schedule.rZ   Nr[   rE   r   )
hasattrr   rZ   r[   r5   r   rm   r   rf   r   )r=   r   r   rZ   r[   r   s         r    r   -DPMSolverSDEScheduler._convert_to_exponential  s    
 4;;,,--II4;;,,--II!*!6IIbM<N<N<P	!*!6IIaL<M<M<O	DHHY$7)9LNabcr   alphabetac           
      J   [        U R                  S5      (       a  U R                  R                  nOSn[        U R                  S5      (       a  U R                  R                  nOSnUb  UOUS   R	                  5       nUb  UOUS   R	                  5       n[
        R                  " S[
        R                  " SSU5      -
   Vs/ s H-  n[        R                  R                  R                  XsU5      PM/     sn Vs/ s H  nXXXe-
  -  -   PM     sn5      n	U	$ s  snf s  snf )zJFrom "Beta Sampling is All You Need" [arXiv:2407.12173] (Lee et. al, 2024)rZ   Nr[   rE   r   r   )r  r   rZ   r[   r5   r   r   r   scipystatsr  ppf)
r=   r   r   r  r  rZ   r[   r   r  r   s
             r    r   &DPMSolverSDEScheduler._convert_to_beta  s    4;;,,--II4;;,,--II!*!6IIbM<N<N<P	!*!6IIaL<M<M<O	
 %&Aq:M(N$N$N KK$$(($?$NC I$9:;
 s   4D?D c                     U R                   S L $ rO   )r   r   s    r    r   *DPMSolverSDEScheduler.state_in_first_order
  s    {{d""r   model_outputreturn_dicts_noisec                    U R                   c  U R                  U5        U R                  c^  U R                  U R                  S:     R	                  5       U R                  R                  5       pv[        X6XpR                  5      U l        S[        R                  S[        R                  4S jnS[        R                  S[        R                  4S jn	U R                  (       a6  U R                  U R                      n
U R                  U R                   S-      nO5U R                  U R                   S-
     n
U R                  U R                      nS	nU	" U
5      U	" U5      pX-
  nXU-  -   nU R                  R                  S
:X  a$  U R                  (       a  U
OU" U5      nUUU-  -
  nOU R                  R                  S:X  a:  U R                  (       a  U
OU" U5      nUU* US-  S-   S	-  -  -  UUS-  S-   -  -   nOHU R                  R                  S:X  a  [        S5      e[        SU R                  R                   S35      eUS:X  a  UU-
  U
-  nX-
  nUUU-  -   nOU R                  (       a  UnOU R                  nU" U5      nU" U5      n[	        UUS-  US-  US-  -
  -  US-  -  S	-  5      nUS-  US-  -
  S	-  nU	" U5      nU" U5      U" U5      -  U-  UU-
  R!                  5       U-  -
  nUU R                  U" U5      U" U5      5      U-  U-  -   nU R                  (       a  X0l        U" U5      U l        OSU l        SU l        U =R$                  S-  sl        U(       d  UU4$ ['        UUS9$ )a*  
Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
process from the learned model outputs (most often the predicted noise).

Args:
    model_output (`torch.Tensor` or `np.ndarray`):
        The direct output from learned diffusion model.
    timestep (`float` or `torch.Tensor`):
        The current discrete timestep in the diffusion chain.
    sample (`torch.Tensor` or `np.ndarray`):
        A current instance of a sample created by the diffusion process.
    return_dict (`bool`):
        Whether or not to return a [`~schedulers.scheduling_dpmsolver_sde.DPMSolverSDESchedulerOutput`] or
        tuple.
    s_noise (`float`, *optional*, defaults to 1.0):
        Scaling factor for noise added to the sample.

Returns:
    [`~schedulers.scheduling_dpmsolver_sde.DPMSolverSDESchedulerOutput`] or `tuple`:
        If return_dict is `True`, [`~schedulers.scheduling_dpmsolver_sde.DPMSolverSDESchedulerOutput`] is
        returned, otherwise a tuple is returned where the first element is the sample tensor.
Nr   r   r   c                 >    U R                  5       R                  5       $ rO   )negrm   r   s    r    r   ,DPMSolverSDEScheduler.step.<locals>.sigma_fn5  s    668<<>!r   r   c                 >    U R                  5       R                  5       $ rO   )r   r  r   s    r    r   (DPMSolverSDEScheduler.step.<locals>.t_fn8  s    ::<##%%r   r   r   epsilonv_predictionr   r   z+prediction_type not implemented yet: samplezprediction_type given as z, must be one of `epsilon`, or `v_prediction`)r   r   )r   r   r   r   rs   r   rR   r   r   r   r   r   r   r   rp   r   expm1r   r   r   )r=   r  r   r   r  r  	min_sigma	max_sigmar   r   r`   ra   r   rj   t_nextr   r   r   r   
derivativedtr   
sigma_fromsigma_tosigma_up
sigma_downancestral_ts                              r    stepDPMSolverSDEScheduler.step  sz   < ??"!!(+ %#';;t{{Q#?#C#C#Et{{GXy!9&YXoXo!pD	" 	"%,, 	"	& 	&%,, 	& $$KK0ET__q%89J KK! 34ET__5J Kj!16Z
n44
 ;;&&)3#'#<#<%(:BVK#)K,,F#F [[((N:#'#<#<%(:BVK#/K<;PQ>TUCUZ]B]3]#^+q.1,-$  [[((H4%&STT+DKK,G,G+HHtu  ? #775@J#B :?2K((#!!J'H8hkZ]Xq[5P&QT^`aTa&afi%ijH"A+!3;Jz*K#K08A;>&HKeg,L- -K &(:(:8A;QWHX(Y\c(cfn(nnK(($'/'7$ #'+$ 	A$ 
 +{Ymnnr   original_samplesnoiser   c                     U R                   R                  UR                  UR                  S9nUR                  R                  S:X  av  [
        R                  " U5      (       a[  U R                  R                  UR                  [
        R                  S9nUR                  UR                  [
        R                  S9nO@U R                  R                  UR                  5      nUR                  UR                  5      nU R                  c!  U Vs/ s H  o`R                  Xe5      PM     nnOHU R                  b  U R                  /UR                  S   -  nOU R                  /UR                  S   -  nXG   R                  5       n[        UR                  5      [        UR                  5      :  a?  UR                  S5      n[        UR                  5      [        UR                  5      :  a  M?  XU-  -   n	U	$ s  snf )N)r+   r*   r   ro   r   rE   )r   r   r+   r*   typer   is_floating_pointr   ru   r   r   r   r8   flattenr7   	unsqueeze)
r=   r0  r1  r   r   r   rj   step_indicesr`   noisy_sampless
             r    	add_noiseDPMSolverSDEScheduler.add_noise  s    '7'>'>FVF\F\]""''50U5L5LY5W5W!%!2!23C3J3JRWR_R_!2!`!%5%<%<EMMRI!%!2!23C3J3J!K!%5%<%<=I #T]^T]q33AJT]L^L__( OO,yq/AAL !,,-	0BBL$,,.%++%5%;%;!<<OOB'E %++%5%;%;!<< )5=8 _s   G;c                 .    U R                   R                  $ rO   )r   r   r   s    r    __len__DPMSolverSDEScheduler.__len__  s    {{...r   )r   r   r   r   ry   r   r   r   r   r   r   r   r   )i  g_QK?g~jt?r   Nr!  FFFNr   r   rO   )r   )NN)333333?r>  )Tr   ),r   r   r   r   r   r   name_compatiblesorderr
   intr   r   r   r   r   ndarrayr   boolrB   r   r   propertyr   r   r   r   r   r   r   r+   r   r   r   r   r   r   r   r   r   r.  r9  r<  r   ).0es   00r    r~   r~      s;   &P %>>$=qFF$=>LE $(#%BF(,116*/,0 *,, ,, ,, 	,,
 ,,  bjj$u+&= >?,, ,, $D>,, !),, "$,, %SM,, ,, ,, ,,^#1 3 3     ! !(3 ( u||+, 
	< ,0-1	M" M" c5<<'(M" &c]	M"^ 0ELL U\\  TW \a\h\h . dg<?HM[`	> # # !qoELL"**45qo u||+,qo ellBJJ./	qo
 qo qo 
*E1	2qoh,, || <<	
 
B/s ?s   G8r~   )g+?rd   )rf   dataclassesr   typingr   r   r   r   numpyr   r   r:   configuration_utilsr	   r
   utilsr   r   scheduling_utilsr   r   scipy.statsr  r   r"   rR   r|   r~   r   r   r    <module>rO     s     ! / /    A 2 G  8* 8 8"%+ %+P: :8 !)4XC/NK C/r   