bipddlmZddlmZmZmZmZddlZddlZddl m Z ddl m Z mZddlmZmZmZmZmZej*jGdd ZeGd d eZGd d ee Zy)) dataclass)ListOptionalTupleUnionN) ConfigMixinregister_to_config)CommonSchedulerStateFlaxKarrasDiffusionSchedulersFlaxSchedulerMixinFlaxSchedulerOutputadd_noise_commonc eZdZUeed<ej ed<ej ed<ej ed<ej ed<ej ed<dZee ed<dZ eej ed <dZ eejed <dZ eejed <dZeej ed <ededej dej dej dej dej f d Zy) DPMSolverMultistepSchedulerStatecommonalpha_tsigma_tlambda_tinit_noise_sigma timestepsNnum_inference_steps model_outputslower_order_nums prev_timestep cur_samplec|||||||S)Nrrrrrr)clsrrrrrrs s/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/diffusers/schedulers/scheduling_dpmsolver_multistep_flax.pycreatez'DPMSolverMultistepSchedulerState.create4s#-   )__name__ __module__ __qualname__r __annotations__jnpndarrayrrintrrint32rr classmethodr#r r$r"rr"s  [[ [[kkkk!{{)-#-,0M8CKK(/,0hsyy)0)-M8CII&-(,J%, $    ++  ++  ;;  r$rceZdZUeed<y)%FlaxDPMSolverMultistepSchedulerOutputstateN)r%r&r'rr(r r$r"r/r/Hs ++r$r/c eZdZUdZeDcgc]}|j c}}Zeje d<e dZ e dddddd d d d d ddddejfdededededeej$dedededededededededejfd Zd:d!eed"efd#Zd$ed%ed&ed"efd'Zd$ed(ej$d)ed*ej$d"ej$f d+Zd$ed(ej$d)ed,ed*ej$d"ej$f d-Zd$ed.ej$d/eed,ed*ej$d"ej$f d0Zd$ed.ej$d/eed,ed*ej$d"ej$f d1Z d;d$ed(ej$d)ed*ej$d2ed"ee eff d3Z! d:d$ed*ej$d)eed"ej$fd4Z"d$ed5ej$d6ej$d7ej$d"ej$f d8Z#d9Z$ycc}}w)<FlaxDPMSolverMultistepScheduleral DPM-Solver (and the improved version DPM-Solver++) is a fast dedicated high-order solver for diffusion ODEs with the convergence order guarantee. Empirically, sampling by DPM-Solver with only 20 steps can generate high-quality samples, and it can generate quite good samples even in only 10 steps. For more details, see the original paper: https://huggingface.co/papers/2206.00927 and https://huggingface.co/papers/2211.01095 Currently, we support the multistep DPM-Solver for both noise prediction models and data prediction models. We recommend to use `solver_order=2` for guided sampling, and `solver_order=3` for unconditional sampling. We also support the "dynamic thresholding" method in Imagen (https://huggingface.co/papers/2205.11487). For pixel-space diffusion models, you can set both `algorithm_type="dpmsolver++"` and `thresholding=True` to use the dynamic thresholding. Note that the thresholding method is unsuitable for latent-space diffusion models (such as stable-diffusion). [`~ConfigMixin`] takes care of storing all config attributes that are passed in the scheduler's `__init__` function, such as `num_train_timesteps`. They can be accessed via `scheduler.config.num_train_timesteps`. [`SchedulerMixin`] provides general loading and saving functionality via the [`SchedulerMixin.save_pretrained`] and [`~SchedulerMixin.from_pretrained`] functions. For more details, see the original paper: https://huggingface.co/papers/2206.00927 and https://huggingface.co/papers/2211.01095 Args: num_train_timesteps (`int`): number of diffusion steps used to train the model. beta_start (`float`): the starting `beta` value of inference. beta_end (`float`): the final `beta` value. beta_schedule (`str`): 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): option to pass an array of betas directly to the constructor to bypass `beta_start`, `beta_end` etc. solver_order (`int`, default `2`): the order of DPM-Solver; can be `1` or `2` or `3`. We recommend to use `solver_order=2` for guided sampling, and `solver_order=3` for unconditional sampling. prediction_type (`str`, default `epsilon`): indicates whether the model predicts the noise (epsilon), or the data / `x0`. One of `epsilon`, `sample`, or `v-prediction`. thresholding (`bool`, default `False`): whether to use the "dynamic thresholding" method (introduced by Imagen, https://huggingface.co/papers/2205.11487). For pixel-space diffusion models, you can set both `algorithm_type=dpmsolver++` and `thresholding=True` to use the dynamic thresholding. Note that the thresholding method is unsuitable for latent-space diffusion models (such as stable-diffusion). dynamic_thresholding_ratio (`float`, default `0.995`): the ratio for the dynamic thresholding method. Default is `0.995`, the same as Imagen (https://huggingface.co/papers/2205.11487). sample_max_value (`float`, default `1.0`): the threshold value for dynamic thresholding. Valid only when `thresholding=True` and `algorithm_type="dpmsolver++`. algorithm_type (`str`, default `dpmsolver++`): the algorithm type for the solver. Either `dpmsolver` or `dpmsolver++`. The `dpmsolver` type implements the algorithms in https://huggingface.co/papers/2206.00927, and the `dpmsolver++` type implements the algorithms in https://huggingface.co/papers/2211.01095. We recommend to use `dpmsolver++` with `solver_order=2` for guided sampling (e.g. stable-diffusion). solver_type (`str`, default `midpoint`): the solver type for the second-order solver. Either `midpoint` or `heun`. The solver type slightly affects the sample quality, especially for small number of steps. We empirically find that `midpoint` solvers are slightly better, so we recommend to use the `midpoint` type. lower_order_final (`bool`, default `True`): whether to use lower-order solvers in the final steps. Only valid for < 15 inference steps. We empirically find this trick can stabilize the sampling of DPM-Solver for steps < 15, especially for steps <= 10. 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. dtype (`jnp.dtype`, *optional*, defaults to `jnp.float32`): the `dtype` used for params and computation. dtypecy)NTr selfs r" has_statez)FlaxDPMSolverMultistepScheduler.has_statesr$ig-C6?g{Gz?linearNrepsilonFgףp= ?? dpmsolver++midpointTlinspacenum_train_timesteps beta_startbeta_end beta_schedule trained_betas solver_orderprediction_type thresholdingdynamic_thresholding_ratiosample_max_valuealgorithm_type solver_typelower_order_finaltimestep_spacingc||_yNr3)r6r>r?r@rArBrCrDrErFrGrHrIrJrKr3s r"__init__z(FlaxDPMSolverMultistepScheduler.__init__s & r$rreturnc|tj|}tj|j}tjd|jz }tj |tj |z }|j jdvr.t|j jd|j|j jdvr.t|j jd|jtjd|j}tjd|j jjddd}t j|||||| S) Nr ) dpmsolverr;z is not implemented for )r<heunr:rNrr)r r#r)sqrtalphas_cumprodlogconfigrHNotImplementedError __class__rIarrayr3aranger>roundr)r6rrrrrrs r" create_statez,FlaxDPMSolverMultistepScheduler.create_statesK >)006F((6001((1v4445777#cggg&66 ;; % %-I I%)C)C(DD\]a]k]k\l&mn n ;; " "*> >%)@)@(AAYZ^ZhZhYi&jk k99S ;JJq$++"A"ABHHJ4R4P /66- 7  r$r0rshapec|jj}|jjdk(rStjd|dz |dzj dddddj tj}nD|jjdk(r||dzz}tjd|dz|zj dddddjj tj}||jjz }n|jjdk(rp|jj|z }tj|d| j jj tj}|dz}n"t|jjdtj|jjf|z|j }tjd}tjd} tj||j } |j||||| | S) a Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference. Args: state (`DPMSolverMultistepSchedulerState`): the `FlaxDPMSolverMultistepScheduler` state data class instance. num_inference_steps (`int`): the number of diffusion steps used when generating samples with a pre-trained model. shape (`Tuple`): the shape of the samples to be generated. r=rr NrTleadingtrailingzY is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'.rN)rrrrrr)rXr>rKr)r=r]astyper,r\copy steps_offset ValueErrorzerosrCr3replace) r6r0rr_ last_timestepr step_ratiorrrrs r" set_timestepsz-FlaxDPMSolverMultistepScheduler.set_timestepss 77 ;; ' ': 5 Q  13F3JKQQSTXVXTXYZ][]^eefifofop [[ ) )Y 6&+>+BCJA2Q67*DKKMdPRdSTWUWX]]_ffgjgpgpq  11 1I [[ ) )Z 788;NNJ =!j[AGGINNPWWX[XaXabI NI;;//01JK   4;;#;#;"="ETZZX 99Q< " YYuDJJ7 }} 3'-'!   r$ model_outputtimestepsamplec |jjdk(r|jjdk(r*|j||j|}}|||zz |z }n|jjdk(r|}nf|jjdk(r*|j||j|}}||z||zz }n#t d|jjd|jj rtjtj||jjttd|j}tj||jjtj |z}tj"|| ||z }|S|jjd k(r|jjdk(r|S|jjdk(r+|j||j|}}|||zz |z } | S|jjdk(r+|j||j|}}||z||zz} | St d|jjdy ) a Convert the model output to the corresponding type that the algorithm (DPM-Solver / DPM-Solver++) 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. So we need to first convert the model output to the corresponding type to match the algorithm. Note that the algorithm type and the model type is decoupled. That is to say, we can use either DPM-Solver or DPM-Solver++ for both noise prediction model and data prediction model. Args: model_output (`jnp.ndarray`): direct output from learned diffusion model. timestep (`int`): current discrete timestep in the diffusion chain. sample (`jnp.ndarray`): current instance of sample being created by diffusion process. Returns: `jnp.ndarray`: the converted model output. r;r9rn v_predictionzprediction_type given as z` must be one of `epsilon`, `sample`, or `v_prediction` for the FlaxDPMSolverMultistepScheduler.r axisrRN)rXrHrDrrrfrEr) percentileabsrFtuplerangendimmaximumrG ones_likeclip) r6r0rlrmrnrrx0_preddynamic_max_valr9s r"convert_model_outputz4FlaxDPMSolverMultistepScheduler.convert_model_outputs_6 ;; % % 6{{**i7#(==#:EMM(#(==#:EMM(#(==#:EMM( ==+U]]2-> x  ;; % % 6W$.'SWWaR[3=N2OSU1UUC [[ ' '; 6W$.'SWWQZ#=M2NRT1TTC r$model_output_list timestep_listc||d|d}}}|d|d} } |j||j||j|} } } |j||j|}}|j||j|}}| | z | | z }}||z }| d|z | | z z}}|jjdk(r|jj dk(rM||z |z|t j| dz z|zz d|t j| dz zz|zz }|S|jj dk(rN||z |z|t j| dz z|zz |t j| dz |z dzz|zz}S|jjdk(r|jj dk(rK||z |z|t j|dz z|zz d|t j|dz zz|zz }|S|jj dk(rL||z |z|t j|dz z|zz |t j|dz |z dz z|zz }S) ac One step for the second-order multistep DPM-Solver. Args: model_output_list (`List[jnp.ndarray]`): direct outputs from learned diffusion model at current and latter timesteps. timestep (`int`): current and latter discrete timestep in the diffusion chain. prev_timestep (`int`): previous discrete timestep in the diffusion chain. sample (`jnp.ndarray`): current instance of sample being created by diffusion process. Returns: `jnp.ndarray`: the sample tensor at the previous timestep. rTr:r;r<?rSrR)rrrrXrHrIr)r)r6r0rrrrnrrs1rm1r lambda_s0 lambda_s1ralpha_s0rsigma_s0rh_0r0D0D1rs r"(multistep_dpm_solver_second_order_updatezHFlaxDPMSolverMultistepScheduler.multistep_dpm_solver_second_order_updatels,"=#4mB6Gr2"2&(9"(=B).):ENN2?2EF  r$c,||d|d|df\}}}} |d|d|d} } } |j||j||j||j| f\} }}}|j||j|}}|j||j|}}| |z ||z ||z }}}||z ||z }}| }d|z | | z zd|z | | z z}}||||zz ||z zz}d||zz ||z z}|jjdk(r|||z |z|t j | dz z|zz |t j | dz |z dzz|zz|t j | dz |z|dzz dz z|zz }|S|jjdk(rw||z |z|t j |dz z|zz |t j |dz |z dz z|zz |t j |dz |z |dzz dz z|zz }S) ab One step for the third-order multistep DPM-Solver. Args: model_output_list (`List[jnp.ndarray]`): direct outputs from learned diffusion model at current and latter timesteps. timestep (`int`): current and latter discrete timestep in the diffusion chain. prev_timestep (`int`): previous discrete timestep in the diffusion chain. sample (`jnp.ndarray`): current instance of sample being created by diffusion process. Returns: `jnp.ndarray`: the sample tensor at the previous timestep. rTrr:r;rrrRr) r6r0rrrrnrrrs2rrm2rrr lambda_s2rrrrrrh_1rr1rD1_0D1_1rD2rs r"'multistep_dpm_solver_third_order_updatezGFlaxDPMSolverMultistepScheduler.multistep_dpm_solver_third_order_updates,&}R'8-:K][]M^^ 2r2&r*,=b,ACTUWCXB NN1  NN2  NN2  NN2  5 1)Y "MM!,emmB.?!MM!,emmB.?*I ,A9yCX3q#'B Bh27+cBh27-Cd R27^t 4 4R"Wo$+ . ;; % % 68#v-cggqbkC/0B67swwr{S0A5;<BCswwr{S0141.step_1sE55##B' +##   r$c Rdtdtjffd }dtdtjffd }||}||}jjdk(r|Sjj r~t |jdkrftjj|jdk|tjjt |jdz k(||Stjj|jdk||S)Nr0rPctj|jdz |jg}j||j||j |j S)Nr )r)r[rrrrrr0rr6rs r"step_2zEFlaxDPMSolverMultistepScheduler.step..step_23..step_2sa # 5??:>+JEOO\fLg*h i DD''!''$$ r$ctj|jdz |jdz |jg}j||j||j |j S)Nrr )r)r[rrrrrrs r"step_3zEFlaxDPMSolverMultistepScheduler.step..step_23..step_3"sx #  Q7 Q7 3! CC''!''$$ r$r) rr)r*rXrCrJlenrjaxlaxselectr)r0rr step_2_output step_3_outputr6rs r"step_23z5FlaxDPMSolverMultistepScheduler.step..step_23s > 3;;  > 3;;  #5MM"5MM{{''1,$$..3u3G"3Lww~~**Q.!GGNN"c%//&:Q&>>%%ww~~**Q.!!r$r)r) prev_sampler0)rrfr)whererrrrrr}rollratsetrhrr*rXrCrJrminimumr/)r6r0rlrmrnrrmodel_outputs_newrr step_1_outputstep_23_outputrrs` @r"stepz$FlaxDPMSolverMultistepScheduler.steps14  $ $ ,s  %//X"=AF ] zS5IA5M'MqRWRaRablopbpRqr 00 hPVW HHU%8%8"1E-00488F +'   : s{{ / ;/  / bu   ;; # #q ('K [[ * *s5??/Cb/H''..&&*#eoo"6"::!"K''..&&*K   [[)?)?!)CT[[E]E]^ ' '4TYZZr$c|S)a Ensures interchangeability with schedulers that need to scale the denoising model input depending on the current timestep. Args: state (`DPMSolverMultistepSchedulerState`): the `FlaxDPMSolverMultistepScheduler` state data class instance. sample (`jnp.ndarray`): input sample timestep (`int`, optional): current timestep Returns: `jnp.ndarray`: scaled input sample r )r6r0rnrms r"scale_model_inputz1FlaxDPMSolverMultistepScheduler.scale_model_inputis  r$original_samplesnoiserc2t|j|||SrM)rr)r6r0rrrs r" add_noisez)FlaxDPMSolverMultistepScheduler.add_noise{s  .>yQQr$c.|jjSrM)rXr>r5s r"__len__z'FlaxDPMSolverMultistepScheduler.__len__s{{...r$rM)T)%r%r&r'__doc__r name _compatiblesr)r3r(propertyr7r float32r+floatstrrr*boolrOr rr^rrkr}rrrrrr/rrrr).0es00r"r2r2MsCJ%BBqAFFBL 99 $("%/3(",1"%+%"& *;;!       , %*   yy!( 8,@#A Mm :4 54 LO4 X]4 )4 lD/DkkD D  D  DL!/!kk! !  !  ! !F:/:;;:Cy :  :  : :x6/6;;6Cy 6  6  6 6|! G[/G[kkG[ G[  G[  G[ 4e; <G[Tgk5?B{{V^_bVc $R/R++R{{ R ;; R  R/cCsG1r2) dataclassesrtypingrrrrflaxr jax.numpynumpyr)configuration_utilsr r scheduling_utils_flaxr r rrrstructrr/r2r r$r"rsw""// A" " " J ,,?, ,x/&8+x/r$