o Git @sddlZddlmZddlZddlZddlmZmZddl m Z m Z m Z ddl mZddlmZmZmZe r;ddlZe eZ dd ed ed eddejfddZGdddeeZdS)N)Literal) ConfigMixinregister_to_config) deprecateis_scipy_availablelogging) randn_tensor)KarrasDiffusionSchedulersSchedulerMixinSchedulerOutput+?cosinenum_diffusion_timestepsmax_betaalpha_transform_type)rexplaplacereturncCs|dkr dd}n|dkrdd}n|dkrdd}ntd|g}t|D]}||}|d |}|td |||||q(tj|tjd 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`, defaults to `0.999`): The maximum beta to use; use values lower than 1 to avoid numerical instability. alpha_transform_type (`str`, defaults to `"cosine"`): The type of noise schedule for `alpha_bar`. Choose from `cosine`, `exp`, or `laplace`. Returns: `torch.Tensor`: The betas used by the scheduler to step the model outputs. rcSs t|ddtjddS)NgMb?gT㥛 ?r)mathcospitrh/home/ubuntu/.local/lib/python3.10/site-packages/diffusers/schedulers/scheduling_dpmsolver_singlestep.py alpha_bar_fn>s z)betas_for_alpha_bar..alpha_bar_fnrc SsPdtdd|tddtd|d}t|}t|d|S)Ngr ?rgư>)rcopysignlogfabsrsqrt)rlmbsnrrrrrCs4 rcSst|dS)Ng()rrrrrrrJsz"Unsupported alpha_transform_type: r dtype) ValueErrorrangeappendmintorchtensorfloat32)rrrrbetasit1t2rrrbetas_for_alpha_bar$s     "r2c2@seZdZdZddeDZdZeddddd d d d d dddd d d d d dded d d dfde dedede dde j e eBd Bde de ddededed e d!d"e d#d$ed%ed&ed'ed(ed)ed*e d+d,ed-e d.d Bd/ed0e dd1d f0d2d3Zd4e d1e e fd5d6Zed1e fd7d8Zed1e fd9d:ZdzdZ d{d4e d?eejBd@ed BdAe e d BfdBdCZdDejd1ejfdEdFZdGe j dHe j d1e j fdIdJZdGejd1eejejffdKdLZdMejd4e d1ejfdNdOZdMejd4e d1ejfdPdQZ Rd|dMejd4e dSedTed1ejf dUdVZ d dWdXejdDejd Bd1ejfdYdZZ!d d d[dXejdDejd Bd\ejd Bd1ejfd]d^Z"d d d[d_e ejdDejd Bd\ejd Bd1ejfd`daZ#d d d[d_e ejdDejd Bd\ejd Bd1ejfdbdcZ$d d d ddd_e ejdDejd Bdee d\ejd Bd1ejf dfdgZ% d}dhe ejBdiejd Bd1e fdjdkZ&dhe ejBd1d fdldmZ' nd~dXejdhe ejBdDejdoej(d Bdped1e)eBf dqdrZ*dDejd1ejfdsdtZ+duejd\ejdAej,d1ejfdvdwZ-d1e fdxdyZ.d S)DPMSolverSinglestepScheduleru `DPMSolverSinglestepScheduler` is a fast dedicated high-order solver for diffusion ODEs. This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic methods the library implements for all schedulers such as loading and saving. Args: num_train_timesteps (`int`, defaults to `1000`): The number of diffusion steps to train the model. beta_start (`float`, defaults to `0.0001`): The starting `beta` value of inference. beta_end (`float`, defaults to `0.02`): The final `beta` value. beta_schedule (`"linear"`, `"scaled_linear"`, or `"squaredcos_cap_v2"`, defaults to `"linear"`): The beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from `linear`, `scaled_linear`, or `squaredcos_cap_v2`. trained_betas (`np.ndarray` or `list[float]`, *optional*): Pass an array of betas directly to the constructor to bypass `beta_start` and `beta_end`. solver_order (`int`, defaults to `2`): The DPMSolver order which can be `1` or `2` or `3`. It is recommended to use `solver_order=2` for guided sampling, and `solver_order=3` for unconditional sampling. prediction_type (`"epsilon"`, `"sample"`, `"v_prediction"`, or `"flow_prediction"`, defaults to `"epsilon"`): Prediction type of the scheduler function; can be `epsilon` (predicts the noise of the diffusion process), `sample` (directly predicts the noisy sample`), `v_prediction` (see section 2.4 of [Imagen Video](https://huggingface.co/papers/2210.02303) paper), or `flow_prediction`. thresholding (`bool`, defaults to `False`): Whether to use the "dynamic thresholding" method. This is unsuitable for latent-space diffusion models such as Stable Diffusion. dynamic_thresholding_ratio (`float`, defaults to `0.995`): The ratio for the dynamic thresholding method. Valid only when `thresholding=True`. sample_max_value (`float`, defaults to `1.0`): The threshold value for dynamic thresholding. Valid only when `thresholding=True` and `algorithm_type="dpmsolver++"`. algorithm_type (`"dpmsolver"`, `"dpmsolver++"`, or `"sde-dpmsolver++"`, defaults to `"dpmsolver++"`): Algorithm type for the solver; can be `dpmsolver`, `dpmsolver++`, or `sde-dpmsolver++`. The `dpmsolver` type implements the algorithms in the [DPMSolver](https://huggingface.co/papers/2206.00927) paper, and the `dpmsolver++` type implements the algorithms in the [DPMSolver++](https://huggingface.co/papers/2211.01095) paper. It is recommended to use `dpmsolver++` or `sde-dpmsolver++` with `solver_order=2` for guided sampling like in Stable Diffusion. solver_type (`"midpoint"` or `"heun"`, defaults to `"midpoint"`): Solver type for the second-order solver; can be `midpoint` or `heun`. The solver type slightly affects the sample quality, especially for a small number of steps. It is recommended to use `midpoint` solvers. lower_order_final (`bool`, defaults to `False`): Whether to use lower-order solvers in the final steps. Only valid for < 15 inference steps. This can stabilize the sampling of DPMSolver for steps < 15, especially for steps <= 10. use_karras_sigmas (`bool`, *optional*, defaults to `False`): Whether to use Karras sigmas for step sizes in the noise schedule during the sampling process. If `True`, the sigmas are determined according to a sequence of noise levels {σi}. use_exponential_sigmas (`bool`, *optional*, defaults to `False`): Whether to use exponential sigmas for step sizes in the noise schedule during the sampling process. use_beta_sigmas (`bool`, *optional*, defaults to `False`): Whether to use beta sigmas for step sizes in the noise schedule during the sampling process. Refer to [Beta Sampling is All You Need](https://huggingface.co/papers/2407.12173) for more information. use_flow_sigmas (`bool`, *optional*, defaults to `False`): Whether to use flow sigmas for step sizes in the noise schedule during the sampling process. flow_shift (`float`, *optional*, defaults to `1.0`): The flow shift parameter for flow-based models. final_sigmas_type (`"zero"` or `"sigma_min"`, *optional*, defaults to `"zero"`): The final `sigma` value for the noise schedule during the sampling process. If `"sigma_min"`, the final sigma is the same as the last sigma in the training schedule. If `"zero"`, the final sigma is set to 0. lambda_min_clipped (`float`, defaults to `-inf`): Clipping threshold for the minimum value of `lambda(t)` for numerical stability. This is critical for the cosine (`squaredcos_cap_v2`) noise schedule. variance_type (`"learned"` or `"learned_range"`, *optional*): Set to `"learned"` or `"learned_range"` for diffusion models that predict variance. If set, the model's output contains the predicted Gaussian variance. use_dynamic_shifting (`bool`, defaults to `False`): Whether to use dynamic shifting for the noise schedule. time_shift_type (`"exponential"`, defaults to `"exponential"`): The type of time shifting to apply. cCsg|]}|jqSr)name).0errr sz'DPMSolverSinglestepScheduler.r ig-C6?g{Gz?linearNrepsilonFgףp= ?? dpmsolver++midpointzeroinf exponentialnum_train_timesteps beta_startbeta_end beta_schedule)r8 scaled_linearsquaredcos_cap_v2 trained_betas solver_orderprediction_type)r9sample v_predictionflow_prediction thresholdingdynamic_thresholding_ratiosample_max_valuealgorithm_type dpmsolverr;sde-dpmsolver++ solver_typer<heunlower_order_finaluse_karras_sigmasuse_exponential_sigmasuse_beta_sigmasuse_flow_sigmas flow_shiftfinal_sigmas_type)r= sigma_minlambda_min_clipped variance_typelearned learned_rangeuse_dynamic_shiftingtime_shift_typercCsV|jjr ts tdt|jj|jj|jjgdkrtd| dkr*d}tdd||dur8t j |t j d|_ n:|d krHt j |||t j d|_ n*|d kr^t j |d |d |t j dd |_ n|d krht||_ n t|d|jd|j |_t j|jdd|_t |j|_t d|j|_t |jt |j|_d|j|jd |_d|_| dvr| dkr|jddn t| d|j| dvr| dvr|jddn t| d|j| dvr|dkrtd|d| dd|_tj d|d|tj dddd}t ||_ dg||_!d|_"|#||_$d|_%d|_&|j'd |_dS)!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.rQzalgorithm_type `dpmsolver` is deprecated and will be removed in a future version. Choose from `dpmsolver++` or `sde-dpmsolver++` insteadzalgorithm_types=dpmsolver1.0.0r%r8rDrrrEz is not implemented for r:rdimrPdeisr;)rOrT)logrhobh1bh2r<)rSr;rRr=z`final_sigmas_type` z' is not supported for `algorithm_type` z$. Please choose `sigma_min` instead.cpu)(configrYr ImportErrorsumrXrWr'rr+r,r-r.linspacer2NotImplementedError __class__alphascumprodalphas_cumprodr"alpha_tsigma_tr lambda_tsigmasinit_noise_sigmarnum_inference_stepsnpcopy from_numpy timesteps model_outputsrIget_order_list order_list _step_index _begin_indexto)selfr@rArBrCrFrGrHrLrMrNrOrSrVrWrXrYrZr[r\r^r_rcrddeprecation_messagerrrr__init__s\ $  &   z%DPMSolverSinglestepScheduler.__init__r}cCsV|}|jj}|dkrtd|jjr||dkrM|ddkr.gd|ddddgdg}nq|ddkr@gd|ddg}n_gd|dddg}nR|dkrr|ddkrfddg|ddddg}n9ddg|ddg}n-|dkr{dg|}n#|dkrgd|d}n|dkrddg|d}n |dkrdg|}|jjdkrd|d<|S) aC Computes the solver order at each time step. Args: num_inference_steps (`int`): The number of diffusion steps used when generating samples with a pre-trained model. Returns: `list[int]`: The list of solver orders for each timestep. z,Order > 3 is not supported by this schedulerr)r rrr rr=rm)rorGr'rVr\)rr}stepsorderordersrrrrs6  $     z+DPMSolverSinglestepScheduler.get_order_listcC|jS)z The index counter for current timestep. It will increase 1 after each scheduler step. Returns: `int` or `None`: The current step index. )rrrrr step_index) z'DPMSolverSinglestepScheduler.step_indexcCr)z The index for the first timestep. It should be set from pipeline with `set_begin_index` method. Returns: `int` or `None`: The begin index. rrrrr begin_index4rz(DPMSolverSinglestepScheduler.begin_indexrrcCs ||_dS)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)rrrrrset_begin_index@s z,DPMSolverSinglestepScheduler.set_begin_indexdevicemurc s|durjjrjjdksJt|j_|dur#|dur#td|dur/|dur/td|dur;jjr;td|durGjjrGtd|durSjj rStd|pXt |}|_ |durjt | tj}n2ttjdgjj}|}tdjjd||dddd dd  tj}t djjd }t|jjrt|}j||d }t fd d |D}njjrt|}j||d }t fdd |D}nfjj rt|}j||d }t fdd |D}nEjjrItddjj|d}d|}tjj|djjd|dd }|jj}n t|t dt ||}jj!dkrldjdjdd }njj!dkrvd}n tdjj!t"||gg tj#}t$|j%|d_&t$|j%|tjd_'dgjj(_)d_*jj+s|jj(dkrt,-dj.ddjj+s܈jj!dkrt,-dj.dd/|_0d_1d_2j&%d_&dS)a  Sets the discrete timesteps used for the diffusion chain (to be run before inference). Args: num_inference_steps (`int`, *optional*): The number of diffusion steps used when generating samples with a pre-trained model. device (`str` or `torch.device`, *optional*): The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. timesteps (`list[int]`, *optional*): Custom timesteps used to support arbitrary spacing between timesteps. If `None`, then the default timestep spacing strategy of equal spacing between timesteps schedule is used. If `timesteps` is passed, `num_inference_steps` must be `None`. Nr?z?Must pass exactly one of `num_inference_steps` or `timesteps`.zDPMSolverSinglestepScheduler.set_timesteps..crrrrrrrr7rcrrrrrrrr7rr:r]r=zC `final_sigmas_type` must be one of `sigma_min` or `zero`, but got )rrr&zChanging scheduler {self.config} to have `lower_order_final` set to True to handle uneven amount of inference steps. Please make sure to always use an even number of `num_inference steps when using `lower_order_final=False`.T)rVz `last_sigmas_type='zero'` is not supported for `lower_order_final=False`. Changing scheduler {self.config} to have `lower_order_final` set to True.rn)3rorcrdr~rr[r'rWrXrYlenr}arrayastypeint64r+ searchsortedfliprzr^itemrrr@roundrrwr _convert_to_karras_convert_to_exponential_convert_to_betarZinterparanger\ concatenater-rrr{rrGrrIrVloggerwarningrrrrr) rr}rrr clipped_idxr{ru sigma_lastrrr set_timestepsJs      2    z*DPMSolverSinglestepScheduler.set_timestepsrIcCs|j}|j^}}}|tjtjfvr|}|||t|}| }tj ||j j dd}tj |d|j jd}|d}t || ||}|j||g|R}||}|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. r rf)r*max)r&shaper+r-float64floatreshaper~prodabsquantilerorMclamprN unsqueezer)rrIr& batch_sizechannelsremaining_dims abs_samplesrrr_threshold_samples    z.DPMSolverSinglestepScheduler._threshold_samplerrc Cstt|d}||ddtjf}tj|dkddjddj|jddd}|d}||}||}||||} t| dd} d| || |} | |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 ) r~r maximumnewaxiscumsumargmaxcliprr) rrr log_sigmadistslow_idxhigh_idxlowhighwrrrrrs, z(DPMSolverSinglestepScheduler._sigma_to_tcCs@|jjrd|}|}||fSd|ddd}||}||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. r rr)rorZ)rrrxryrrr_sigma_to_alpha_sigma_ts z4DPMSolverSinglestepScheduler._sigma_to_alpha_sigma_trc Cst|jdr |jj}nd}t|jdr|jj}nd}|dur |n|d}|dur,|n|d}d}tdd|}|d|}|d|}|||||} | 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. r]N sigma_maxrmrg@r )hasattrror]rrr~rr) rrr}r]rrhoramp min_inv_rho max_inv_rhor{rrrrs      z/DPMSolverSinglestepScheduler._convert_to_karrascCst|jdr |jj}nd}t|jdr|jj}nd}|dur |n|d}|dur,|n|d}ttt |t ||}|S)a Construct an exponential noise schedule. 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 an exponential schedule. r]Nrrmr) rror]rrr~rrrrr )rrr}r]rr{rrrrEs     z4DPMSolverSinglestepScheduler._convert_to_exponential333333?alphabetac st|jdr |jjndt|jdr|jjnddur n|ddur,n|dtfddfddd tdd |DD}|S) a Construct a beta noise schedule as proposed in [Beta Sampling is All You Need](https://huggingface.co/papers/2407.12173). 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. alpha (`float`, *optional*, defaults to `0.6`): The alpha parameter for the beta distribution. beta (`float`, *optional*, defaults to `0.6`): The beta parameter for the beta distribution. Returns: `torch.Tensor`: The converted sigma values following a beta distribution schedule. r]Nrrmrcsg|] }|qSrr)r5ppf)rr]rrr7szADPMSolverSinglestepScheduler._convert_to_beta..csg|] }tjj|qSr)scipystatsrr)r5timestep)rrrrr7sr )rror]rrr~rrr)rrr}rrr{r)rrrr]rrgs       z-DPMSolverSinglestepScheduler._convert_to_betarI model_outputc Osrt|dkr |dn|dd}|dur#t|dkr|d}ntd|dur-tddd|jjd vr|jjd kr_|jjd vrI|dddd f}|j|j }| |\}}||||} nB|jjd krh|} n9|jjdkr|j|j }| |\}}||||} n|jjdkr|j|j }|||} n td|jjd|jj r| | } | S|jjdkr7|jjd kr|jjd vr|dddd f} nF|} nC|jjd kr|j|j }| |\}}||||} n'|jjdkr|j|j }| |\}}||||} n td|jjd|jj r5|j ||j|}}||| |} | | } ||| |} | SdS)a Convert the model output to the corresponding type the DPMSolver/DPMSolver++ algorithm needs. DPM-Solver is designed to discretize an integral of the noise prediction model, and DPM-Solver++ is designed to discretize an integral of the data prediction model. > [!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 argumentrrePassing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`rlr9r`rrIrJrKzprediction_type given as zo must be one of `epsilon`, `sample`, `v_prediction`, or `flow_prediction` for the DPMSolverSinglestepScheduler.rQz\ must be one of `epsilon`, `sample`, or `v_prediction` for the DPMSolverSinglestepScheduler.)rpopr'rrorOrHr_r{rrrLrrxry) rrrIargskwargsrrrxryx0_predr9rrrconvert_model_outputsp                    z1DPMSolverSinglestepScheduler.convert_model_outputrInoiserc Ost|dkr |dn|dd}t|dkr|dn|dd}|dur3t|dkr/|d}ntd|dur=tdd d |durGtdd d |j|jd|j|j}} ||\} }|| \} } t| t|} t| t| } | | }|j j d kr|| || t | d |}|S|j j dkr| | ||t |d |}|S|j j dkr|dusJ|| t | || dt d|||t d t d||}|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_timesteprrrrerPassing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`r;r:rQrR) rrr'rr{rrr+r rorOrr")rrrIrrrrrrysigma_srxalpha_srzlambda_shx_trrrdpm_solver_first_order_updatesN     $ " z:DPMSolverSinglestepScheduler.dpm_solver_first_order_updatemodel_output_listc Ost|dkr |dn|dd}t|dkr|dn|dd}|dur3t|dkr/|d}ntd|dur=tddd |durGtddd |j|jd|j|j|j|jd}} } ||\} }|| \} } || \} } t| t|}t| t| }t| t| }|d |d }}||||}}||}|d |||}}|j j dkr |j j dkr|| || t | d |d| t | d |}|S|j j dkr || || t | d || t | d |d |}|S|j j dkrd|j j dkr;| | ||t |d |d|t |d |}|S|j j dkrb| | ||t |d ||t |d |d |}|S|j j dkr|dusrJ|j j dkr|| t | || dt d||d| dt d|||t d t d ||}|S|j j dkr|| t | || dt d||| d t d|d|d ||t d t d ||}|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_listNr rrrrePassing `timestep_list` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`rrmrr:r;r<rrUrQrRrrrr'rr{rrr+r rorOrSrr")rrrIrrrrrrysigma_s0sigma_s1rxalpha_s0alpha_s1rz lambda_s0 lambda_s1m0m1rh_0r0D0D1rrrr)singlestep_dpm_solver_second_order_update7s        ) #   $zFDPMSolverSinglestepScheduler.singlestep_dpm_solver_second_order_updatec" Ost|dkr |dn|dd}t|dkr|dn|dd}|dur3t|dkr/|d}ntd|dur=tddd |durGtddd |j|jd|j|j|j|jd|j|jdf\}} } } ||\} }|| \} } || \}} || \}} t| t|}t| t| }t|t| }t|t| }|d |d |d }}}||||||}}}||||}}|}d|||d|||}}||||||}d||||} |j j dkrj|j j dkr+|| || t | d|| t | d|d|}!|!S|j j dkrh|| || t | d|| t | d|d|| t | d||dd| }!|!S|j j dkr|j j dkr| |||t |d||t |d|d|}!|!S|j j dkr| |||t |d||t |d|d||t |d||dd| }!|!S|j j dkr|dusJ|j j dkr)|| t | || dt d||| dt d|d|d||t dt d ||}!|!S|j j dkr|| t | || dt d||| dt d|d|d|| dt d|d|d|dd| |t dt d ||}!|!S)a One step for the third-order singlestep DPMSolver that computes the solution at time `prev_timestep` from the time `timestep_list[-3]`. 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. Returns: `torch.Tensor`: The sample tensor at the previous timestep. rrNr rrrrerrrmrr:g@r;r<rUrrQrRrr)"rrrIrrrrrryrrsigma_s2rxrralpha_s2rzrr lambda_s2rrm2rrh_1rr1rD1_0D1_1rD2rrrr(singlestep_dpm_solver_third_order_updates      " , &&  $$$0zEDPMSolverSinglestepScheduler.singlestep_dpm_solver_third_order_updaterIrrrc Ost|dkr |dn|dd}t|dkr|dn|dd}|dur3t|dkr/|d}ntd|durFt|dkrB|d}ntd |durPtdd d |durZtdd d |dkrh|j|d ||dS|dkrt|j|||dS|dkr|j|||dStd|)a One step for the singlestep DPMSolver. Args: model_output_list (`list[torch.Tensor]`): The direct outputs from learned diffusion model at current and latter timesteps. timestep (`int`): The current and latter discrete timestep in the diffusion chain. prev_timestep (`int`): The previous discrete timestep in the diffusion chain. sample (`torch.Tensor`): A current instance of a sample created by diffusion process. order (`int`): The solver order at this step. Returns: `torch.Tensor`: The sample tensor at the previous timestep. rrNr rrrrz.missing `order` as a required keyword argumentrerrrmrzOrder must be 1, 2, 3, got )rrr'rrrr) rrrIrrrrrrrrrsinglestep_dpm_solver_update s:      z9DPMSolverSinglestepScheduler.singlestep_dpm_solver_updaterschedule_timestepscCsd|dur|j}||k}t|dkrt|jd}|St|dkr*|d}|S|d}|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. Nrr )rnonzerorr)rrrindex_candidatesrrrrindex_for_timestep`s    z/DPMSolverSinglestepScheduler.index_for_timestepcCs@|jdurt|tjr||jj}|||_dS|j |_dS)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+Tensorrrrrrr)rrrrr_init_step_indexs  z-DPMSolverSinglestepScheduler._init_step_indexT generator return_dictc Cs |jdur td|jdur|||j||d}t|jjdD] }|j|d|j|<q"||jd<|jj dkrFt |j ||j |j d}nd}|j|j}|j| durb|d8}|j| dusV|dkri||_|j|j|j||d} |jd7_|s| fSt| d 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` or `torch.Tensor`): The current discrete timestep in the diffusion chain. sample (`torch.Tensor`): A current instance of a sample created by the diffusion process. generator (`torch.Generator`, *optional*): A random number generator for stochastic sampling. return_dict (`bool`, defaults to `True`): Whether or not to return a [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`. Returns: [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`: If return_dict is `True`, [`~schedulers.scheduling_utils.SchedulerOutput`] is returned, otherwise a tuple is returned where the first element is the sample tensor. NzaNumber of inference steps is 'None', you need to run 'set_timesteps' after creating the schedulerrr rmrR)rrr&r) prev_sample)r}r'rrrr(rorGrrOr rrr&rrIrrr ) rrrrIrrr/rrrrrrsteps8        z!DPMSolverSinglestepScheduler.stepcOs|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)rrIrrrrrscale_model_inputs z.DPMSolverSinglestepScheduler.scale_model_inputoriginal_samplesc sjj|j|jd}|jjdkr)t|r)jj|jtjd|j|jtjd}n j|j||j}j durFfdd|D}nj durUj g|j d}n j g|j d}|| }t |j t |j kr}|d}t |j t |j ksn|\}}||||} | S) 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%Ncrr)r)r5rrrrrr7rz:DPMSolverSinglestepScheduler.add_noise..rrm)r{rrr&typer+is_floating_pointrr-rrrflattenrrr) rrrrr{ step_indicesrrxry noisy_samplesrr!r add_noises$     z&DPMSolverSinglestepScheduler.add_noisecCs|jjSN)ror@rrrr__len__sz$DPMSolverSinglestepScheduler.__len__)r)NNNN)rrr()NT)/__name__ __module__ __qualname____doc__r _compatiblesrrrintrr~ndarraylistboolrrpropertyrrrstrr+rrrrrtuplerrrrrrrrrrr Generatorr rr IntTensorr'r)rrrrr3XsH       X,     m, %'# 4 d D s ~ C % I 1r3)rr)rtypingrnumpyr~r+configuration_utilsrrutilsrrrutils.torch_utilsr scheduling_utilsr r r scipy.statsr get_loggerr*rr/rrr2r3rrrrs.    4