3jhSSKrSSKJr SSKJrJrJr SSKrSSK r SSK J r J r SSK JrJrJr SSKJr \"5(aSSKr\R*"\5r\"S S \55r"S S \\ 5rg) N) dataclass)LiteralOptionalUnion) ConfigMixinregister_to_config) BaseOutputis_scipy_availablelogging)SchedulerMixinc8\rSrSr%Sr\R \S'Srg)%FlowMatchEulerDiscreteSchedulerOutput!a2 Output class for the scheduler's `step` function output. Args: prev_sample (`torch.FloatTensor` 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. prev_sampleN) __name__ __module__ __qualname____firstlineno____doc__torch FloatTensor__annotations____static_attributes__rs/home/wildlama/miniconda3/lib/python3.13/site-packages/diffusers/schedulers/scheduling_flow_match_euler_discrete.pyrr!s"""rrc \rSrSrSr/rSr\SES\S\ S\ S \ S-S \ S-S \S \S \ S\ S\ S\ S\ S\ SS\ 4Sjj5r \ S5r\ S5r\ S5rSFS\4SjjrS\ 4SjrSGS\R(S\ \R(-S\R(S-S\R(4S jjrS\ 4S!jrS"\ S#\ S$\R.S\R.4S%jrS$\R.S\R.4S&jrSHS'\S-S(\\R6-S)\\ S-S"\ S-S*\\ S-4 S+jjrSGS\\ \R(4S,\\R(S\4S-jjr S\\ \R(4SS4S.jr!S/S/\ "S05SSSS14S2\R(S\ \R(-S\R(S3\ S4\ S5\ S6\ S7\RDS-S8\R.S-S9\ S\#\$-4S:jjr%S;\R.S'\S\R.4S<jr&S;\R.S'\S\R.4S=jr'SIS;\R.S'\S>\ S?\ S\R.4 S@jjr(S"\ S#\ S$\R.S\R.4SAjr)S"\ S#\ S$\R.S\R.4SBjr*S\4SCjr+SDr,g)JFlowMatchEulerDiscreteScheduler/a Euler scheduler. 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. shift (`float`, defaults to 1.0): The shift value for the timestep schedule. use_dynamic_shifting (`bool`, defaults to False): Whether to apply timestep shifting on-the-fly based on the image resolution. base_shift (`float`, defaults to 0.5): Value to stabilize image generation. Increasing `base_shift` reduces variation and image is more consistent with desired output. max_shift (`float`, defaults to 1.15): Value change allowed to latent vectors. Increasing `max_shift` encourages more variation and image may be more exaggerated or stylized. base_image_seq_len (`int`, defaults to 256): The base image sequence length. max_image_seq_len (`int`, defaults to 4096): The maximum image sequence length. invert_sigmas (`bool`, defaults to False): Whether to invert the sigmas. shift_terminal (`float`, defaults to None): The end value of the shifted timestep schedule. use_karras_sigmas (`bool`, defaults to False): Whether to use Karras sigmas for step sizes in the noise schedule during sampling. use_exponential_sigmas (`bool`, defaults to False): Whether to use exponential sigmas for step sizes in the noise schedule during sampling. use_beta_sigmas (`bool`, defaults to False): Whether to use beta sigmas for step sizes in the noise schedule during sampling. time_shift_type (`str`, defaults to "exponential"): The type of dynamic resolution-dependent timestep shifting to apply. Either "exponential" or "linear". stochastic_sampling (`bool`, defaults to False): Whether to use stochastic sampling. r ?Nnum_train_timestepsshiftuse_dynamic_shifting base_shift max_shiftbase_image_seq_lenmax_image_seq_len invert_sigmasshift_terminaluse_karras_sigmasuse_exponential_sigmasuse_beta_sigmastime_shift_type) exponentiallinearstochastic_samplingc<URR(a[5(d [S5e[ URRURR URR /5S:a [S5eU S;a [S5e[R"SX[RS9SSS2R5n[R"U5R[RS9nX- nU(dUU-SUS- U--- nUU-UlSUlSUlX lURS5UlUR&SR)5UlUR&S R)5Ulg) 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.>r1r0z;`time_shift_type` must either be 'exponential' or 'linear'.dtypecpur)configr.r ImportErrorsumr-r, ValueErrornplinspacefloat32copyr from_numpyto timesteps _step_index _begin_index_shiftsigmasitem sigma_min sigma_max)selfr#r$r%r&r'r(r)r*r+r,r-r.r/r2rBrFs r__init__(FlowMatchEulerDiscreteScheduler.__init__Zsj$ ;; & &/A/C/CZ[ [ KK//KK66KK11  A  "; ;Z[ [KK#6SUS]S]^_cac_cdiik $$Y/222G 0#V^qEAI+?'?@F"55  ii& R--/Q,,.rcUR$)z The value used for shifting. rErJs rr$%FlowMatchEulerDiscreteScheduler.shifts {{rcUR$)zW The index counter for current timestep. It will increase 1 after each scheduler step. )rCrOs r step_index*FlowMatchEulerDiscreteScheduler.step_indexs rcUR$)za The index for the first timestep. It should be set from pipeline with `set_begin_index` method. rDrOs r begin_index+FlowMatchEulerDiscreteScheduler.begin_indexs    rrVcXlg)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. NrU)rJrVs rset_begin_index/FlowMatchEulerDiscreteScheduler.set_begin_indexs (rcXlg)zh Sets the shift value for the scheduler. Args: shift (`float`): The shift value to be set. NrN)rJr$s r set_shift)FlowMatchEulerDiscreteScheduler.set_shifts  rsampletimestepnoisereturnc URRURURS9nURRS:Xav[ R "U5(a[URRUR[ RS9nURUR[ RS9nO@URRUR5nURUR5nURc!UVs/sHo`RXe5PM nnOHURbUR/URS-nOUR/URS-nXGR5n[UR5[UR5:a?URS5n[UR5[UR5:aM?X-SU- U--nU$s snf)a; Forward process in flow-matching Args: sample (`torch.FloatTensor`): The input sample. timestep (`torch.FloatTensor`): The current timestep in the diffusion chain. noise (`torch.FloatTensor`): The noise tensor. Returns: `torch.FloatTensor`: A scaled input sample. )devicer5mpsr4rr6r")rFrArcr5typeris_floating_pointrBr>rVindex_for_timesteprRshapeflattenlen unsqueeze) rJr^r_r`rFschedule_timestepst step_indicessigmas r scale_noise+FlowMatchEulerDiscreteScheduler.scale_noises,v}}FLLI ==   &5+B+B8+L+L!%!2!26== !2!V {{6== {FH!%!2!26==!A {{6==1H    #T\]T\q33AJT\L]L __ ( OO,x~~a/@@L!,,-q0AAL$,,.%++V\\!22OOB'E%++V\\!22#+!77 ^sHc2XRR-$Nr8r#)rJros r _sigma_to_t+FlowMatchEulerDiscreteScheduler._sigma_to_ts{{6666rmurormcURRS:XaURXU5$URRS:XaURXU5$g)a& Apply time shifting to the sigmas. Args: mu (`float`): The mu parameter for the time shift. sigma (`float`): The sigma parameter for the time shift. t (`torch.Tensor`): The input timesteps. Returns: `torch.Tensor`: The time-shifted timesteps. r0r1N)r8r/_time_shift_exponential_time_shift_linearrJrwrorms r time_shift*FlowMatchEulerDiscreteScheduler.time_shiftsS ;; & &- 7//1= = [[ ( (H 4**2a8 85rc\SU- nUSSURR- - nSX#- - nU$)a Stretches and shifts the timestep schedule to ensure it terminates at the configured `shift_terminal` config value. Reference: https://github.com/Lightricks/LTX-Video/blob/a01a171f8fe3d99dce2728d60a73fecf4d4238ae/ltx_video/schedulers/rf.py#L51 Args: t (`torch.Tensor`): A tensor of timesteps to be stretched and shifted. Returns: `torch.Tensor`: A tensor of adjusted timesteps such that the final value equals `self.config.shift_terminal`. r r6)r8r+)rJrm one_minus_z scale_factor stretched_ts rstretch_shift_to_terminal9FlowMatchEulerDiscreteScheduler.stretch_shift_to_terminals= !e "2!dkk.H.H*HI ;56 rnum_inference_stepsrcrFrBcURR(aUc [S5eUb&Ub#[U5[U5:wa [S5eUb0Ub[U5U:wdUb[U5U:wa [S5eOUb [U5O [U5nXlUSLnU(a3[ R "U5R[ R5nUcfUcJ[ R"URUR5URUR5U5nXPRR- nO>[ R "U5R[ R5n[U5nURR(aURUSU5nO%URU-SURS- U--- nURR (aUR#U5nURR$(aUR'X1S9nOUURR((aUR+X1S9nO*URR,(aUR/X1S9n[0R2"U5R5[0RUS9nU(dX0RR-nO2[0R2"U5R5[0RUS9nURR6(aSSU- nX0RR-n[0R8"U[0R:"SUR<S 9/5nO5[0R8"U[0R>"SUR<S 9/5nXPl X0l!SUl"SUl#g) ar 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. sigmas (`list[float]`, *optional*): Custom values for sigmas to be used for each diffusion step. If `None`, the sigmas are computed automatically. mu (`float`, *optional*): Determines the amount of shifting applied to sigmas when performing resolution-dependent timestep shifting. timesteps (`list[float]`, *optional*): Custom values for timesteps to be used for each diffusion step. If `None`, the timesteps are computed automatically. NzC`mu` must be passed when `use_dynamic_shifting` is set to be `True`z4`sigmas` and `timesteps` should have the same lengthzq`sigmas` and `timesteps` should have the same length as num_inference_steps, if `num_inference_steps` is providedr"r ) in_sigmasr)r5rc)rc)$r8r%r;rjrr<arrayastyper>r=rurIrHr#r|r$r+rr,_convert_to_karrasr-_convert_to_exponentialr._convert_to_betarr@rAr*catonesrczerosrBrFrCrD)rJrrcrFrwrBis_timesteps_provideds r set_timesteps-FlowMatchEulerDiscreteScheduler.set_timestepss4 ;; + + bc c  )"76{c)n, !WXX  *"s6{6I'I%#i.I > KK$$T^^4$$T^^4' !@!@@FXXf%,,RZZ8F"%f+  ;; + +__Rf5FZZ&(Aa60I,IJF ;; % %33F;F ;; ( (,,v,gF [[ / /11F1lF [[ ( (**V*eF!!&),,5==,P$!@!@@I((366U]]SY6ZI ;; $ $6\F!@!@@IYY 1V]](KLMFYY Afmm(LMNF"  rrlcUc URnX!:HR5n[U5S:aSOSnX4R5$)a^ Get the index for the given timestep. Args: timestep (`float` or `torch.FloatTensor`): The timestep to find the index for. schedule_timesteps (`torch.FloatTensor`, *optional*): The schedule timesteps to validate against. If `None`, the scheduler's timesteps are used. Returns: `int`: The index of the timestep. r r)rBnonzerorjrG)rJr_rlindicesposs rrg2FlowMatchEulerDiscreteScheduler.index_for_timestepsJ$  %!% %1::< w[U[R5(d[U[R5(a [ S5eUR cURU5 UR[R5nU b[XRR- n URSS2SS4n XSS- :n X-nURSS9upU SnUSnUU- nO6UR nURUnURUS-nUnUnUU- nURR(a-UUU-- n[R"U5nSU- U-UU--nOUUU--nU=R S- slU cURUR"5nU (dU4$[%US 9$) aU 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.FloatTensor`): The direct output from learned diffusion model. timestep (`float`): The current discrete timestep in the diffusion chain. sample (`torch.FloatTensor`): A current instance of a sample created by the diffusion process. s_churn (`float`): s_tmin (`float`): s_tmax (`float`): s_noise (`float`, defaults to 1.0): Scaling factor for noise added to the sample. generator (`torch.Generator`, *optional*): A random number generator. per_token_timesteps (`torch.Tensor`, *optional*): The timesteps for each token in the sample. return_dict (`bool`, defaults to `True`): Whether or not to return a [`~schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteSchedulerOutput`] or tuple. Returns: [`~schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteSchedulerOutput`] or `tuple`: If return_dict is `True`, [`~schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteSchedulerOutput`] is returned, otherwise a tuple is returned where the first element is the sample tensor. zPassing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to `FlowMatchEulerDiscreteScheduler.step()` is not supported. Make sure to pass one of the `scheduler.timesteps` as a timestep.Ngư>r)dim).Nr r")r)rintr IntTensor LongTensorr;rRrrAr>r8r#rFmaxr2 randn_likerCr5r)rJrr_r^rrrrrrrper_token_sigmasrF lower_mask lower_sigmas_ current_sigma next_sigmadt sigma_idxro sigma_nextx0r`rs rstep$FlowMatchEulerDiscreteScheduler.stepsZ x % %(EOO44(E$4$455G  ?? "  ! !( +5==)  *2[[5T5TT [[D$/F4"84"??J%.L*..1.5OL,Y7M%i0J+BIKK *EY]3J!M#Je#B ;; * *-,66B$$V,E+r1J4FFK 2 #44K A  &%..);); !4MMrrc[URS5(aURRnOSn[URS5(aURRnOSnUbUOUSR 5nUbUOUSR 5nSn[ R "SSU5nUSU- -nUSU- -nXXx- --U-n U $)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. rHNrIr6rg@r )hasattrr8rHrIrGr<r=) rJrrrHrIrhoramp min_inv_rho max_inv_rhorFs rr2FlowMatchEulerDiscreteScheduler._convert_to_karrass$ 4;; , , --II 4;; , , --II!*!6IIbM1ue6G6G/G)H1T1e ,037 cN''cN%+++cN!! cN  cN  cNcNcN??T)cN#\\D0cNcN / 6cNL$ELL$s$W\WcWc$NTW\a\h\hFdg..rsn !++ A;;,   H %  #J #  #` /nk` /r