import{S as N5,i as L5,s as q5,e as s,k as l,w as f,t as i,M as K5,c as o,d as t,m as c,a as n,x as h,h as a,b as d,G as e,g as p,y as m,q as g,o as _,B as v,v as R5}from"../../chunks/vendor-hf-doc-builder.js";import{T as Q5}from"../../chunks/Tip-hf-doc-builder.js";import{D as b}from"../../chunks/Docstring-hf-doc-builder.js";import{I as w}from"../../chunks/IconCopyLink-hf-doc-builder.js";function j5(tc){let Z,ct;return{c(){Z=s("p"),ct=i("Score SDE-VP is under construction.")},l(ee){Z=o(ee,"P",{});var De=n(Z);ct=a(De,"Score SDE-VP is under construction."),De.forEach(t)},m(ee,De){p(ee,Z,De),e(Z,ct)},d(ee){ee&&t(Z)}}}function W5(tc){let Z,ct,ee,De,Ki,Ir,Lp,Ri,qp,rc,ln,Kp,sc,Le,ut,Qi,Nr,Rp,ji,Qp,oc,pt,jp,Wi,Wp,Up,nc,ft,cn,Bp,Lr,Ui,Hp,Gp,Bi,zp,Yp,qe,Jp,Hi,Xp,Zp,Gi,ef,tf,ic,Ke,ht,zi,qr,rf,Yi,sf,ac,O,of,Ji,nf,af,un,df,lf,pn,cf,uf,Xi,pf,ff,fn,hf,mf,Zi,gf,_f,dc,Re,mt,ea,Kr,vf,ta,bf,lc,hn,Sf,cc,gt,ra,Df,xf,sa,$f,uc,Qe,_t,oa,Rr,Ef,na,yf,pc,mn,wf,fc,Ce,Qr,Mf,ia,Pf,Tf,Cf,jr,kf,aa,Of,Af,Vf,da,Ff,hc,vt,If,gn,Nf,Lf,mc,je,bt,la,Wr,qf,ca,Kf,gc,We,Ur,Rf,ua,Qf,_c,Ue,St,pa,Br,jf,fa,Wf,vc,Be,Hr,Uf,ha,Bf,bc,He,Dt,ma,Gr,Hf,ga,Gf,Sc,Ge,xt,_a,zr,zf,va,Yf,Dc,_n,Jf,xc,P,Yr,Xf,ba,Zf,eh,A,vn,th,rh,Sa,sh,oh,Da,nh,ih,xa,ah,dh,bn,lh,ch,Sn,uh,ph,Dn,fh,hh,mh,xn,gh,Jr,_h,vh,$t,Xr,bh,$a,Sh,Dh,Et,Zr,xh,Ea,$h,Eh,yt,es,yh,ya,wh,$c,ze,wt,wa,ts,Mh,Ma,Ph,Ec,Mt,Th,rs,Ch,kh,yc,T,ss,Oh,Pa,Ah,Vh,V,$n,Fh,Ih,Ta,Nh,Lh,Ca,qh,Kh,ka,Rh,Qh,En,jh,Wh,yn,Uh,Bh,wn,Hh,Gh,zh,Mn,Yh,os,Jh,Xh,Pt,ns,Zh,Oa,em,tm,Tt,is,rm,Aa,sm,om,Ct,as,nm,Va,im,wc,Ye,kt,Fa,ds,am,Ia,dm,Mc,xe,lm,ls,cm,um,cs,pm,fm,us,hm,mm,Pc,S,ps,gm,Na,_m,vm,Ot,bm,fs,Sm,Dm,hs,xm,$m,Je,Em,La,ym,wm,qa,Mm,Pm,Tm,Me,Cm,ms,km,Om,Ka,Am,Vm,Ra,Fm,Im,Nm,F,Pn,Lm,qm,Qa,Km,Rm,ja,Qm,jm,Wa,Wm,Um,Tn,Bm,Hm,Cn,Gm,zm,kn,Ym,Jm,Xm,$e,gs,Zm,Ua,eg,tg,Ba,rg,sg,Ha,og,ng,ke,_s,ig,Ga,ag,dg,vs,lg,bs,cg,ug,pg,At,Ss,fg,za,hg,mg,Vt,Ds,gg,Ya,_g,vg,Ft,xs,bg,Ja,Sg,Dg,It,$s,xg,Xa,$g,Eg,Nt,Es,yg,Za,wg,Tc,Xe,Lt,ed,ys,Mg,td,Pg,Cc,qt,Tg,ws,Cg,kg,kc,x,Ms,Og,rd,Ag,Vg,Kt,Fg,Ps,Ig,Ng,Ts,Lg,qg,I,On,Kg,Rg,sd,Qg,jg,od,Wg,Ug,nd,Bg,Hg,An,Gg,zg,Vn,Yg,Jg,Fn,Xg,Zg,e_,Cs,t_,ks,r_,s_,o_,Oe,Os,n_,id,i_,a_,ad,d_,l_,Rt,As,c_,dd,u_,p_,Qt,Vs,f_,ld,h_,m_,jt,Fs,g_,cd,__,v_,Wt,Is,b_,ud,S_,Oc,Ze,Ut,pd,Ns,D_,fd,x_,Ac,Bt,$_,Ls,E_,y_,Vc,C,qs,w_,In,M_,Ks,P_,T_,N,Nn,C_,k_,hd,O_,A_,md,V_,F_,gd,I_,N_,Ln,L_,q_,qn,K_,R_,Kn,Q_,j_,W_,Ht,Rs,U_,_d,B_,H_,Gt,Qs,G_,js,z_,vd,Y_,J_,X_,zt,Ws,Z_,bd,ev,tv,Yt,Us,rv,Sd,sv,Fc,et,Jt,Dd,Bs,ov,xd,nv,Ic,Xt,iv,Hs,av,dv,Nc,$,Gs,lv,$d,cv,uv,L,Rn,pv,fv,Ed,hv,mv,yd,gv,_v,wd,vv,bv,Qn,Sv,Dv,jn,xv,$v,Wn,Ev,yv,wv,Un,Mv,zs,Pv,Tv,Zt,Ys,Cv,Md,kv,Ov,er,Js,Av,Pd,Vv,Fv,Ae,Xs,Iv,Td,Nv,Lv,Pe,qv,Cd,Kv,Rv,kd,Qv,jv,Od,Wv,Uv,Bv,tr,Zs,Hv,Ad,Gv,zv,rr,eo,Yv,Vd,Jv,Lc,tt,sr,Fd,to,Xv,Id,Zv,qc,or,e1,ro,t1,r1,Kc,E,so,s1,Nd,o1,n1,Bn,i1,oo,a1,d1,q,Hn,l1,c1,Ld,u1,p1,qd,f1,h1,Kd,m1,g1,Gn,_1,v1,zn,b1,S1,Yn,D1,x1,$1,nr,no,E1,Rd,y1,w1,Ve,io,M1,Qd,P1,T1,rt,C1,jd,k1,O1,Wd,A1,V1,F1,ir,ao,I1,Ud,N1,L1,ar,lo,q1,Bd,K1,R1,dr,co,Q1,Hd,j1,Rc,st,lr,Gd,uo,W1,zd,U1,Qc,cr,B1,po,H1,G1,jc,k,fo,z1,Jn,Y1,ho,J1,X1,K,Xn,Z1,eb,Yd,tb,rb,Jd,sb,ob,Xd,nb,ib,Zn,ab,db,ei,lb,cb,ti,ub,pb,fb,ri,hb,mo,mb,gb,ur,go,_b,Zd,vb,bb,pr,_o,Sb,el,Db,xb,fr,vo,$b,tl,Eb,Wc,ot,hr,rl,bo,yb,sl,wb,Uc,mr,Mb,So,Pb,Tb,Bc,gr,Hc,te,Do,Cb,ol,kb,Ob,R,si,Ab,Vb,nl,Fb,Ib,il,Nb,Lb,al,qb,Kb,oi,Rb,Qb,ni,jb,Wb,ii,Ub,Bb,Hb,ai,Gb,xo,zb,Yb,dl,Jb,Gc,nt,_r,ll,$o,Xb,cl,Zb,zc,Fe,e0,Eo,t0,r0,yo,s0,o0,Yc,Y,wo,n0,vr,i0,Mo,a0,d0,Po,l0,c0,Q,di,u0,p0,ul,f0,h0,pl,m0,g0,fl,_0,v0,li,b0,S0,ci,D0,x0,ui,$0,E0,y0,br,To,w0,Co,M0,hl,P0,T0,C0,Sr,ko,k0,ml,O0,A0,Dr,Oo,V0,gl,F0,Jc,it,xr,_l,Ao,I0,vl,N0,Xc,pi,L0,Zc,J,Vo,q0,fi,K0,Fo,R0,Q0,j,hi,j0,W0,bl,U0,B0,Sl,H0,G0,Dl,z0,Y0,mi,J0,X0,gi,Z0,e2,_i,t2,r2,s2,$r,Io,o2,No,n2,xl,i2,a2,d2,Er,Lo,l2,$l,c2,u2,yr,qo,p2,El,f2,eu,at,wr,yl,Ko,h2,wl,m2,tu,Ro,g2,Qo,_2,ru,y,jo,v2,Ml,b2,S2,Pl,D2,x2,W,vi,$2,E2,Tl,y2,w2,Cl,M2,P2,kl,T2,C2,bi,k2,O2,Si,A2,V2,Di,F2,I2,N2,xi,L2,Wo,q2,K2,Ie,Uo,R2,Bo,Q2,Ol,j2,W2,U2,Al,B2,H2,U,Ho,G2,Go,z2,Vl,Y2,J2,X2,Fl,Z2,e4,Il,t4,r4,Nl,s4,o4,Ll,zo,n4,ql,i4,a4,d4,dt,l4,Kl,c4,u4,Rl,p4,f4,h4,Mr,Yo,m4,Ql,g4,_4,Pr,Jo,v4,Xo,b4,jl,S4,D4,su,lt,Tr,Wl,Zo,x4,Ul,$4,ou,Te,E4,$i,y4,w4,en,M4,P4,tn,T4,nu,X,rn,C4,Bl,k4,O4,B,Ei,A4,V4,Hl,F4,I4,Gl,N4,L4,zl,q4,K4,yi,R4,Q4,wi,j4,W4,Mi,U4,B4,H4,Pi,G4,sn,z4,Y4,Cr,on,J4,Yl,X4,Z4,kr,nn,eS,Jl,tS,iu;return Ir=new w({}),Nr=new w({}),qr=new w({}),Kr=new w({}),Rr=new w({}),Wr=new w({}),Ur=new b({props:{name:"class diffusers.SchedulerMixin",anchor:"diffusers.SchedulerMixin",parameters:[],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_utils.py#L38"}}),Br=new w({}),Hr=new b({props:{name:"class diffusers.schedulers.scheduling_utils.SchedulerOutput",anchor:"diffusers.schedulers.scheduling_utils.SchedulerOutput",parameters:[{name:"prev_sample",val:": FloatTensor"}],parametersDescription:[{anchor:"diffusers.schedulers.scheduling_utils.SchedulerOutput.prev_sample",description:`<strong>prev_sample</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_channels, height, width)</code> for images) &#x2014;
Computed sample (x_{t-1}) of previous timestep. <code>prev_sample</code> should be used as next model input in the
denoising loop.`,name:"prev_sample"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_utils.py#L25"}}),Gr=new w({}),zr=new w({}),Yr=new b({props:{name:"class diffusers.DDIMScheduler",anchor:"diffusers.DDIMScheduler",parameters:[{name:"num_train_timesteps",val:": int = 1000"},{name:"beta_start",val:": float = 0.0001"},{name:"beta_end",val:": float = 0.02"},{name:"beta_schedule",val:": str = 'linear'"},{name:"trained_betas",val:": typing.Optional[numpy.ndarray] = None"},{name:"clip_sample",val:": bool = True"},{name:"set_alpha_to_one",val:": bool = True"},{name:"steps_offset",val:": int = 0"}],parametersDescription:[{anchor:"diffusers.DDIMScheduler.num_train_timesteps",description:"<strong>num_train_timesteps</strong> (<code>int</code>) &#x2014; number of diffusion steps used to train the model.",name:"num_train_timesteps"},{anchor:"diffusers.DDIMScheduler.beta_start",description:"<strong>beta_start</strong> (<code>float</code>) &#x2014; the starting <code>beta</code> value of inference.",name:"beta_start"},{anchor:"diffusers.DDIMScheduler.beta_end",description:"<strong>beta_end</strong> (<code>float</code>) &#x2014; the final <code>beta</code> value.",name:"beta_end"},{anchor:"diffusers.DDIMScheduler.beta_schedule",description:`<strong>beta_schedule</strong> (<code>str</code>) &#x2014;
the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
<code>linear</code>, <code>scaled_linear</code>, or <code>squaredcos_cap_v2</code>.`,name:"beta_schedule"},{anchor:"diffusers.DDIMScheduler.trained_betas",description:`<strong>trained_betas</strong> (<code>np.ndarray</code>, optional) &#x2014;
option to pass an array of betas directly to the constructor to bypass <code>beta_start</code>, <code>beta_end</code> etc.`,name:"trained_betas"},{anchor:"diffusers.DDIMScheduler.clip_sample",description:`<strong>clip_sample</strong> (<code>bool</code>, default <code>True</code>) &#x2014;
option to clip predicted sample between -1 and 1 for numerical stability.`,name:"clip_sample"},{anchor:"diffusers.DDIMScheduler.set_alpha_to_one",description:`<strong>set_alpha_to_one</strong> (<code>bool</code>, default <code>True</code>) &#x2014;
each diffusion step uses the value of alphas product at that step and at the previous one. For the final
step there is no previous alpha. When this option is <code>True</code> the previous alpha product is fixed to <code>1</code>,
otherwise it uses the value of alpha at step 0.`,name:"set_alpha_to_one"},{anchor:"diffusers.DDIMScheduler.steps_offset",description:`<strong>steps_offset</strong> (<code>int</code>, default <code>0</code>) &#x2014;
an offset added to the inference steps. You can use a combination of <code>offset=1</code> and
<code>set_alpha_to_one=False</code>, to make the last step use step 0 for the previous alpha product, as done in
stable diffusion.`,name:"steps_offset"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_ddim.py#L78"}}),Xr=new b({props:{name:"scale_model_input",anchor:"diffusers.DDIMScheduler.scale_model_input",parameters:[{name:"sample",val:": FloatTensor"},{name:"timestep",val:": typing.Optional[int] = None"}],parametersDescription:[{anchor:"diffusers.DDIMScheduler.scale_model_input.sample",description:"<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014; input sample",name:"sample"},{anchor:"diffusers.DDIMScheduler.scale_model_input.timestep",description:"<strong>timestep</strong> (<code>int</code>, optional) &#x2014; current timestep",name:"timestep"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_ddim.py#L164",returnDescription:`
<p>scaled input sample</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),Zr=new b({props:{name:"set_timesteps",anchor:"diffusers.DDIMScheduler.set_timesteps",parameters:[{name:"num_inference_steps",val:": int"},{name:"device",val:": typing.Union[str, torch.device] = None"}],parametersDescription:[{anchor:"diffusers.DDIMScheduler.set_timesteps.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>) &#x2014;
the number of diffusion steps used when generating samples with a pre-trained model.`,name:"num_inference_steps"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_ddim.py#L188"}}),es=new b({props:{name:"step",anchor:"diffusers.DDIMScheduler.step",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": int"},{name:"sample",val:": FloatTensor"},{name:"eta",val:": float = 0.0"},{name:"use_clipped_model_output",val:": bool = False"},{name:"generator",val:" = None"},{name:"variance_noise",val:": typing.Optional[torch.FloatTensor] = None"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.DDIMScheduler.step.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.DDIMScheduler.step.timestep",description:"<strong>timestep</strong> (<code>int</code>) &#x2014; current discrete timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.DDIMScheduler.step.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"},{anchor:"diffusers.DDIMScheduler.step.eta",description:"<strong>eta</strong> (<code>float</code>) &#x2014; weight of noise for added noise in diffusion step.",name:"eta"},{anchor:"diffusers.DDIMScheduler.step.use_clipped_model_output",description:`<strong>use_clipped_model_output</strong> (<code>bool</code>) &#x2014; if <code>True</code>, compute &#x201C;corrected&#x201D; <code>model_output</code> from the clipped
predicted original sample. Necessary because predicted original sample is clipped to [-1, 1] when
<code>self.config.clip_sample</code> is <code>True</code>. If no clipping has happened, &#x201C;corrected&#x201D; <code>model_output</code> would
coincide with the one provided as input and <code>use_clipped_model_output</code> will have not effect.
generator &#x2014; random number generator.`,name:"use_clipped_model_output"},{anchor:"diffusers.DDIMScheduler.step.variance_noise",description:`<strong>variance_noise</strong> (<code>torch.FloatTensor</code>) &#x2014; instead of generating noise for the variance using <code>generator</code>, we
can directly provide the noise for the variance itself. This is useful for methods such as
CycleDiffusion. (<a href="https://arxiv.org/abs/2210.05559" rel="nofollow">https://arxiv.org/abs/2210.05559</a>)`,name:"variance_noise"},{anchor:"diffusers.DDIMScheduler.step.return_dict",description:"<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than DDIMSchedulerOutput class",name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_ddim.py#L204",returnDescription:`
<p><code>~schedulers.scheduling_utils.DDIMSchedulerOutput</code> if <code>return_dict</code> is True, otherwise a <code>tuple</code>. When
returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>~schedulers.scheduling_utils.DDIMSchedulerOutput</code> or <code>tuple</code></p>
`}}),ts=new w({}),ss=new b({props:{name:"class diffusers.DDPMScheduler",anchor:"diffusers.DDPMScheduler",parameters:[{name:"num_train_timesteps",val:": int = 1000"},{name:"beta_start",val:": float = 0.0001"},{name:"beta_end",val:": float = 0.02"},{name:"beta_schedule",val:": str = 'linear'"},{name:"trained_betas",val:": typing.Optional[numpy.ndarray] = None"},{name:"variance_type",val:": str = 'fixed_small'"},{name:"clip_sample",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.DDPMScheduler.num_train_timesteps",description:"<strong>num_train_timesteps</strong> (<code>int</code>) &#x2014; number of diffusion steps used to train the model.",name:"num_train_timesteps"},{anchor:"diffusers.DDPMScheduler.beta_start",description:"<strong>beta_start</strong> (<code>float</code>) &#x2014; the starting <code>beta</code> value of inference.",name:"beta_start"},{anchor:"diffusers.DDPMScheduler.beta_end",description:"<strong>beta_end</strong> (<code>float</code>) &#x2014; the final <code>beta</code> value.",name:"beta_end"},{anchor:"diffusers.DDPMScheduler.beta_schedule",description:`<strong>beta_schedule</strong> (<code>str</code>) &#x2014;
the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
<code>linear</code>, <code>scaled_linear</code>, or <code>squaredcos_cap_v2</code>.`,name:"beta_schedule"},{anchor:"diffusers.DDPMScheduler.trained_betas",description:`<strong>trained_betas</strong> (<code>np.ndarray</code>, optional) &#x2014;
option to pass an array of betas directly to the constructor to bypass <code>beta_start</code>, <code>beta_end</code> etc.`,name:"trained_betas"},{anchor:"diffusers.DDPMScheduler.variance_type",description:`<strong>variance_type</strong> (<code>str</code>) &#x2014;
options to clip the variance used when adding noise to the denoised sample. Choose from <code>fixed_small</code>,
<code>fixed_small_log</code>, <code>fixed_large</code>, <code>fixed_large_log</code>, <code>learned</code> or <code>learned_range</code>.`,name:"variance_type"},{anchor:"diffusers.DDPMScheduler.clip_sample",description:`<strong>clip_sample</strong> (<code>bool</code>, default <code>True</code>) &#x2014;
option to clip predicted sample between -1 and 1 for numerical stability.`,name:"clip_sample"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_ddpm.py#L76"}}),ns=new b({props:{name:"scale_model_input",anchor:"diffusers.DDPMScheduler.scale_model_input",parameters:[{name:"sample",val:": FloatTensor"},{name:"timestep",val:": typing.Optional[int] = None"}],parametersDescription:[{anchor:"diffusers.DDPMScheduler.scale_model_input.sample",description:"<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014; input sample",name:"sample"},{anchor:"diffusers.DDPMScheduler.scale_model_input.timestep",description:"<strong>timestep</strong> (<code>int</code>, optional) &#x2014; current timestep",name:"timestep"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_ddpm.py#L157",returnDescription:`
<p>scaled input sample</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),is=new b({props:{name:"set_timesteps",anchor:"diffusers.DDPMScheduler.set_timesteps",parameters:[{name:"num_inference_steps",val:": int"},{name:"device",val:": typing.Union[str, torch.device] = None"}],parametersDescription:[{anchor:"diffusers.DDPMScheduler.set_timesteps.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>) &#x2014;
the number of diffusion steps used when generating samples with a pre-trained model.`,name:"num_inference_steps"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_ddpm.py#L171"}}),as=new b({props:{name:"step",anchor:"diffusers.DDPMScheduler.step",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": int"},{name:"sample",val:": FloatTensor"},{name:"predict_epsilon",val:" = True"},{name:"generator",val:" = None"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.DDPMScheduler.step.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.DDPMScheduler.step.timestep",description:"<strong>timestep</strong> (<code>int</code>) &#x2014; current discrete timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.DDPMScheduler.step.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"},{anchor:"diffusers.DDPMScheduler.step.predict_epsilon",description:`<strong>predict_epsilon</strong> (<code>bool</code>) &#x2014;
optional flag to use when model predicts the samples directly instead of the noise, epsilon.
generator &#x2014; random number generator.`,name:"predict_epsilon"},{anchor:"diffusers.DDPMScheduler.step.return_dict",description:"<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than DDPMSchedulerOutput class",name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_ddpm.py#L219",returnDescription:`
<p><code>~schedulers.scheduling_utils.DDPMSchedulerOutput</code> if <code>return_dict</code> is True, otherwise a <code>tuple</code>. When
returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>~schedulers.scheduling_utils.DDPMSchedulerOutput</code> or <code>tuple</code></p>
`}}),ds=new w({}),ps=new b({props:{name:"class diffusers.DPMSolverMultistepScheduler",anchor:"diffusers.DPMSolverMultistepScheduler",parameters:[{name:"num_train_timesteps",val:": int = 1000"},{name:"beta_start",val:": float = 0.0001"},{name:"beta_end",val:": float = 0.02"},{name:"beta_schedule",val:": str = 'linear'"},{name:"trained_betas",val:": typing.Optional[numpy.ndarray] = None"},{name:"solver_order",val:": int = 2"},{name:"predict_epsilon",val:": bool = True"},{name:"thresholding",val:": bool = False"},{name:"dynamic_thresholding_ratio",val:": float = 0.995"},{name:"sample_max_value",val:": float = 1.0"},{name:"algorithm_type",val:": str = 'dpmsolver++'"},{name:"solver_type",val:": str = 'midpoint'"},{name:"lower_order_final",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.DPMSolverMultistepScheduler.num_train_timesteps",description:"<strong>num_train_timesteps</strong> (<code>int</code>) &#x2014; number of diffusion steps used to train the model.",name:"num_train_timesteps"},{anchor:"diffusers.DPMSolverMultistepScheduler.beta_start",description:"<strong>beta_start</strong> (<code>float</code>) &#x2014; the starting <code>beta</code> value of inference.",name:"beta_start"},{anchor:"diffusers.DPMSolverMultistepScheduler.beta_end",description:"<strong>beta_end</strong> (<code>float</code>) &#x2014; the final <code>beta</code> value.",name:"beta_end"},{anchor:"diffusers.DPMSolverMultistepScheduler.beta_schedule",description:`<strong>beta_schedule</strong> (<code>str</code>) &#x2014;
the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
<code>linear</code>, <code>scaled_linear</code>, or <code>squaredcos_cap_v2</code>.`,name:"beta_schedule"},{anchor:"diffusers.DPMSolverMultistepScheduler.trained_betas",description:`<strong>trained_betas</strong> (<code>np.ndarray</code>, optional) &#x2014;
option to pass an array of betas directly to the constructor to bypass <code>beta_start</code>, <code>beta_end</code> etc.`,name:"trained_betas"},{anchor:"diffusers.DPMSolverMultistepScheduler.solver_order",description:`<strong>solver_order</strong> (<code>int</code>, default <code>2</code>) &#x2014;
the order of DPM-Solver; can be <code>1</code> or <code>2</code> or <code>3</code>. We recommend to use <code>solver_order=2</code> for guided
sampling, and <code>solver_order=3</code> for unconditional sampling.`,name:"solver_order"},{anchor:"diffusers.DPMSolverMultistepScheduler.predict_epsilon",description:`<strong>predict_epsilon</strong> (<code>bool</code>, default <code>True</code>) &#x2014;
we currently support both the noise prediction model and the data prediction model. If the model predicts
the noise / epsilon, set <code>predict_epsilon</code> to <code>True</code>. If the model predicts the data / x0 directly, set
<code>predict_epsilon</code> to <code>False</code>.`,name:"predict_epsilon"},{anchor:"diffusers.DPMSolverMultistepScheduler.thresholding",description:`<strong>thresholding</strong> (<code>bool</code>, default <code>False</code>) &#x2014;
whether to use the &#x201C;dynamic thresholding&#x201D; method (introduced by Imagen, <a href="https://arxiv.org/abs/2205.11487" rel="nofollow">https://arxiv.org/abs/2205.11487</a>).
For pixel-space diffusion models, you can set both <code>algorithm_type=dpmsolver++</code> and <code>thresholding=True</code> to
use the dynamic thresholding. Note that the thresholding method is unsuitable for latent-space diffusion
models (such as stable-diffusion).`,name:"thresholding"},{anchor:"diffusers.DPMSolverMultistepScheduler.dynamic_thresholding_ratio",description:`<strong>dynamic_thresholding_ratio</strong> (<code>float</code>, default <code>0.995</code>) &#x2014;
the ratio for the dynamic thresholding method. Default is <code>0.995</code>, the same as Imagen
(<a href="https://arxiv.org/abs/2205.11487" rel="nofollow">https://arxiv.org/abs/2205.11487</a>).`,name:"dynamic_thresholding_ratio"},{anchor:"diffusers.DPMSolverMultistepScheduler.sample_max_value",description:`<strong>sample_max_value</strong> (<code>float</code>, default <code>1.0</code>) &#x2014;
the threshold value for dynamic thresholding. Valid only when <code>thresholding=True</code> and
<code>algorithm_type=&quot;dpmsolver++</code>.`,name:"sample_max_value"},{anchor:"diffusers.DPMSolverMultistepScheduler.algorithm_type",description:`<strong>algorithm_type</strong> (<code>str</code>, default <code>dpmsolver++</code>) &#x2014;
the algorithm type for the solver. Either <code>dpmsolver</code> or <code>dpmsolver++</code>. The <code>dpmsolver</code> type implements the
algorithms in <a href="https://arxiv.org/abs/2206.00927" rel="nofollow">https://arxiv.org/abs/2206.00927</a>, and the <code>dpmsolver++</code> type implements the algorithms in
<a href="https://arxiv.org/abs/2211.01095" rel="nofollow">https://arxiv.org/abs/2211.01095</a>. We recommend to use <code>dpmsolver++</code> with <code>solver_order=2</code> for guided
sampling (e.g. stable-diffusion).`,name:"algorithm_type"},{anchor:"diffusers.DPMSolverMultistepScheduler.solver_type",description:`<strong>solver_type</strong> (<code>str</code>, default <code>midpoint</code>) &#x2014;
the solver type for the second-order solver. Either <code>midpoint</code> or <code>heun</code>. The solver type slightly affects
the sample quality, especially for small number of steps. We empirically find that <code>midpoint</code> solvers are
slightly better, so we recommend to use the <code>midpoint</code> type.`,name:"solver_type"},{anchor:"diffusers.DPMSolverMultistepScheduler.lower_order_final",description:`<strong>lower_order_final</strong> (<code>bool</code>, default <code>True</code>) &#x2014;
whether to use lower-order solvers in the final steps. Only valid for &lt; 15 inference steps. We empirically
find this trick can stabilize the sampling of DPM-Solver for steps &lt; 15, especially for steps &lt;= 10.`,name:"lower_order_final"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L56"}}),gs=new b({props:{name:"convert_model_output",anchor:"diffusers.DPMSolverMultistepScheduler.convert_model_output",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": int"},{name:"sample",val:": FloatTensor"}],parametersDescription:[{anchor:"diffusers.DPMSolverMultistepScheduler.convert_model_output.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.DPMSolverMultistepScheduler.convert_model_output.timestep",description:"<strong>timestep</strong> (<code>int</code>) &#x2014; current discrete timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.DPMSolverMultistepScheduler.convert_model_output.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L206",returnDescription:`
<p>the converted model output.</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),_s=new b({props:{name:"dpm_solver_first_order_update",anchor:"diffusers.DPMSolverMultistepScheduler.dpm_solver_first_order_update",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": int"},{name:"prev_timestep",val:": int"},{name:"sample",val:": FloatTensor"}],parametersDescription:[{anchor:"diffusers.DPMSolverMultistepScheduler.dpm_solver_first_order_update.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.DPMSolverMultistepScheduler.dpm_solver_first_order_update.timestep",description:"<strong>timestep</strong> (<code>int</code>) &#x2014; current discrete timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.DPMSolverMultistepScheduler.dpm_solver_first_order_update.prev_timestep",description:"<strong>prev_timestep</strong> (<code>int</code>) &#x2014; previous discrete timestep in the diffusion chain.",name:"prev_timestep"},{anchor:"diffusers.DPMSolverMultistepScheduler.dpm_solver_first_order_update.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L255",returnDescription:`
<p>the sample tensor at the previous timestep.</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),Ss=new b({props:{name:"multistep_dpm_solver_second_order_update",anchor:"diffusers.DPMSolverMultistepScheduler.multistep_dpm_solver_second_order_update",parameters:[{name:"model_output_list",val:": typing.List[torch.FloatTensor]"},{name:"timestep_list",val:": typing.List[int]"},{name:"prev_timestep",val:": int"},{name:"sample",val:": FloatTensor"}],parametersDescription:[{anchor:"diffusers.DPMSolverMultistepScheduler.multistep_dpm_solver_second_order_update.model_output_list",description:`<strong>model_output_list</strong> (<code>List[torch.FloatTensor]</code>) &#x2014;
direct outputs from learned diffusion model at current and latter timesteps.`,name:"model_output_list"},{anchor:"diffusers.DPMSolverMultistepScheduler.multistep_dpm_solver_second_order_update.timestep",description:"<strong>timestep</strong> (<code>int</code>) &#x2014; current and latter discrete timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.DPMSolverMultistepScheduler.multistep_dpm_solver_second_order_update.prev_timestep",description:"<strong>prev_timestep</strong> (<code>int</code>) &#x2014; previous discrete timestep in the diffusion chain.",name:"prev_timestep"},{anchor:"diffusers.DPMSolverMultistepScheduler.multistep_dpm_solver_second_order_update.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L287",returnDescription:`
<p>the sample tensor at the previous timestep.</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),Ds=new b({props:{name:"multistep_dpm_solver_third_order_update",anchor:"diffusers.DPMSolverMultistepScheduler.multistep_dpm_solver_third_order_update",parameters:[{name:"model_output_list",val:": typing.List[torch.FloatTensor]"},{name:"timestep_list",val:": typing.List[int]"},{name:"prev_timestep",val:": int"},{name:"sample",val:": FloatTensor"}],parametersDescription:[{anchor:"diffusers.DPMSolverMultistepScheduler.multistep_dpm_solver_third_order_update.model_output_list",description:`<strong>model_output_list</strong> (<code>List[torch.FloatTensor]</code>) &#x2014;
direct outputs from learned diffusion model at current and latter timesteps.`,name:"model_output_list"},{anchor:"diffusers.DPMSolverMultistepScheduler.multistep_dpm_solver_third_order_update.timestep",description:"<strong>timestep</strong> (<code>int</code>) &#x2014; current and latter discrete timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.DPMSolverMultistepScheduler.multistep_dpm_solver_third_order_update.prev_timestep",description:"<strong>prev_timestep</strong> (<code>int</code>) &#x2014; previous discrete timestep in the diffusion chain.",name:"prev_timestep"},{anchor:"diffusers.DPMSolverMultistepScheduler.multistep_dpm_solver_third_order_update.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L346",returnDescription:`
<p>the sample tensor at the previous timestep.</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),xs=new b({props:{name:"scale_model_input",anchor:"diffusers.DPMSolverMultistepScheduler.scale_model_input",parameters:[{name:"sample",val:": FloatTensor"},{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"diffusers.DPMSolverMultistepScheduler.scale_model_input.sample",description:"<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014; input sample",name:"sample"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L469",returnDescription:`
<p>scaled input sample</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),$s=new b({props:{name:"set_timesteps",anchor:"diffusers.DPMSolverMultistepScheduler.set_timesteps",parameters:[{name:"num_inference_steps",val:": int"},{name:"device",val:": typing.Union[str, torch.device] = None"}],parametersDescription:[{anchor:"diffusers.DPMSolverMultistepScheduler.set_timesteps.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>) &#x2014;
the number of diffusion steps used when generating samples with a pre-trained model.`,name:"num_inference_steps"},{anchor:"diffusers.DPMSolverMultistepScheduler.set_timesteps.device",description:`<strong>device</strong> (<code>str</code> or <code>torch.device</code>, optional) &#x2014;
the device to which the timesteps should be moved to. If <code>None</code>, the timesteps are not moved.`,name:"device"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L183"}}),Es=new b({props:{name:"step",anchor:"diffusers.DPMSolverMultistepScheduler.step",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": int"},{name:"sample",val:": FloatTensor"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.DPMSolverMultistepScheduler.step.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.DPMSolverMultistepScheduler.step.timestep",description:"<strong>timestep</strong> (<code>int</code>) &#x2014; current discrete timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.DPMSolverMultistepScheduler.step.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"},{anchor:"diffusers.DPMSolverMultistepScheduler.step.return_dict",description:"<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than SchedulerOutput class",name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py#L401",returnDescription:`
<p><code>~scheduling_utils.SchedulerOutput</code> if <code>return_dict</code> is
True, otherwise a <code>tuple</code>. When returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>~scheduling_utils.SchedulerOutput</code> or <code>tuple</code></p>
`}}),ys=new w({}),Ms=new b({props:{name:"class diffusers.KarrasVeScheduler",anchor:"diffusers.KarrasVeScheduler",parameters:[{name:"sigma_min",val:": float = 0.02"},{name:"sigma_max",val:": float = 100"},{name:"s_noise",val:": float = 1.007"},{name:"s_churn",val:": float = 80"},{name:"s_min",val:": float = 0.05"},{name:"s_max",val:": float = 50"}],parametersDescription:[{anchor:"diffusers.KarrasVeScheduler.sigma_min",description:"<strong>sigma_min</strong> (<code>float</code>) &#x2014; minimum noise magnitude",name:"sigma_min"},{anchor:"diffusers.KarrasVeScheduler.sigma_max",description:"<strong>sigma_max</strong> (<code>float</code>) &#x2014; maximum noise magnitude",name:"sigma_max"},{anchor:"diffusers.KarrasVeScheduler.s_noise",description:`<strong>s_noise</strong> (<code>float</code>) &#x2014; the amount of additional noise to counteract loss of detail during sampling.
A reasonable range is [1.000, 1.011].`,name:"s_noise"},{anchor:"diffusers.KarrasVeScheduler.s_churn",description:`<strong>s_churn</strong> (<code>float</code>) &#x2014; the parameter controlling the overall amount of stochasticity.
A reasonable range is [0, 100].`,name:"s_churn"},{anchor:"diffusers.KarrasVeScheduler.s_min",description:`<strong>s_min</strong> (<code>float</code>) &#x2014; the start value of the sigma range where we add noise (enable stochasticity).
A reasonable range is [0, 10].`,name:"s_min"},{anchor:"diffusers.KarrasVeScheduler.s_max",description:`<strong>s_max</strong> (<code>float</code>) &#x2014; the end value of the sigma range where we add noise.
A reasonable range is [0.2, 80].`,name:"s_max"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_karras_ve.py#L48"}}),Os=new b({props:{name:"add_noise_to_input",anchor:"diffusers.KarrasVeScheduler.add_noise_to_input",parameters:[{name:"sample",val:": FloatTensor"},{name:"sigma",val:": float"},{name:"generator",val:": typing.Optional[torch._C.Generator] = None"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_karras_ve.py#L133"}}),As=new b({props:{name:"scale_model_input",anchor:"diffusers.KarrasVeScheduler.scale_model_input",parameters:[{name:"sample",val:": FloatTensor"},{name:"timestep",val:": typing.Optional[int] = None"}],parametersDescription:[{anchor:"diffusers.KarrasVeScheduler.scale_model_input.sample",description:"<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014; input sample",name:"sample"},{anchor:"diffusers.KarrasVeScheduler.scale_model_input.timestep",description:"<strong>timestep</strong> (<code>int</code>, optional) &#x2014; current timestep",name:"timestep"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_karras_ve.py#L98",returnDescription:`
<p>scaled input sample</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),Vs=new b({props:{name:"set_timesteps",anchor:"diffusers.KarrasVeScheduler.set_timesteps",parameters:[{name:"num_inference_steps",val:": int"},{name:"device",val:": typing.Union[str, torch.device] = None"}],parametersDescription:[{anchor:"diffusers.KarrasVeScheduler.set_timesteps.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>) &#x2014;
the number of diffusion steps used when generating samples with a pre-trained model.`,name:"num_inference_steps"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_karras_ve.py#L112"}}),Fs=new b({props:{name:"step",anchor:"diffusers.KarrasVeScheduler.step",parameters:[{name:"model_output",val:": FloatTensor"},{name:"sigma_hat",val:": float"},{name:"sigma_prev",val:": float"},{name:"sample_hat",val:": FloatTensor"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.KarrasVeScheduler.step.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.KarrasVeScheduler.step.sigma_hat",description:"<strong>sigma_hat</strong> (<code>float</code>) &#x2014; TODO",name:"sigma_hat"},{anchor:"diffusers.KarrasVeScheduler.step.sigma_prev",description:"<strong>sigma_prev</strong> (<code>float</code>) &#x2014; TODO",name:"sigma_prev"},{anchor:"diffusers.KarrasVeScheduler.step.sample_hat",description:"<strong>sample_hat</strong> (<code>torch.FloatTensor</code>) &#x2014; TODO",name:"sample_hat"},{anchor:"diffusers.KarrasVeScheduler.step.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than KarrasVeOutput class</p>
<p>KarrasVeOutput &#x2014; updated sample in the diffusion chain and derivative (TODO double check).`,name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_karras_ve.py#L154",returnDescription:`
<p><code>KarrasVeOutput</code> if <code>return_dict</code> is True, otherwise a <code>tuple</code>. When
returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>KarrasVeOutput</code> or <code>tuple</code></p>
`}}),Is=new b({props:{name:"step_correct",anchor:"diffusers.KarrasVeScheduler.step_correct",parameters:[{name:"model_output",val:": FloatTensor"},{name:"sigma_hat",val:": float"},{name:"sigma_prev",val:": float"},{name:"sample_hat",val:": FloatTensor"},{name:"sample_prev",val:": FloatTensor"},{name:"derivative",val:": FloatTensor"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.KarrasVeScheduler.step_correct.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.KarrasVeScheduler.step_correct.sigma_hat",description:"<strong>sigma_hat</strong> (<code>float</code>) &#x2014; TODO",name:"sigma_hat"},{anchor:"diffusers.KarrasVeScheduler.step_correct.sigma_prev",description:"<strong>sigma_prev</strong> (<code>float</code>) &#x2014; TODO",name:"sigma_prev"},{anchor:"diffusers.KarrasVeScheduler.step_correct.sample_hat",description:"<strong>sample_hat</strong> (<code>torch.FloatTensor</code>) &#x2014; TODO",name:"sample_hat"},{anchor:"diffusers.KarrasVeScheduler.step_correct.sample_prev",description:"<strong>sample_prev</strong> (<code>torch.FloatTensor</code>) &#x2014; TODO",name:"sample_prev"},{anchor:"diffusers.KarrasVeScheduler.step_correct.derivative",description:"<strong>derivative</strong> (<code>torch.FloatTensor</code>) &#x2014; TODO",name:"derivative"},{anchor:"diffusers.KarrasVeScheduler.step_correct.return_dict",description:"<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than KarrasVeOutput class",name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_karras_ve.py#L192",returnDescription:`
<p>updated sample in the diffusion chain. derivative (TODO): TODO</p>
`,returnType:`
<p>prev_sample (TODO)</p>
`}}),Ns=new w({}),qs=new b({props:{name:"class diffusers.LMSDiscreteScheduler",anchor:"diffusers.LMSDiscreteScheduler",parameters:[{name:"num_train_timesteps",val:": int = 1000"},{name:"beta_start",val:": float = 0.0001"},{name:"beta_end",val:": float = 0.02"},{name:"beta_schedule",val:": str = 'linear'"},{name:"trained_betas",val:": typing.Optional[numpy.ndarray] = None"}],parametersDescription:[{anchor:"diffusers.LMSDiscreteScheduler.num_train_timesteps",description:"<strong>num_train_timesteps</strong> (<code>int</code>) &#x2014; number of diffusion steps used to train the model.",name:"num_train_timesteps"},{anchor:"diffusers.LMSDiscreteScheduler.beta_start",description:"<strong>beta_start</strong> (<code>float</code>) &#x2014; the starting <code>beta</code> value of inference.",name:"beta_start"},{anchor:"diffusers.LMSDiscreteScheduler.beta_end",description:"<strong>beta_end</strong> (<code>float</code>) &#x2014; the final <code>beta</code> value.",name:"beta_end"},{anchor:"diffusers.LMSDiscreteScheduler.beta_schedule",description:`<strong>beta_schedule</strong> (<code>str</code>) &#x2014;
the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
<code>linear</code> or <code>scaled_linear</code>.`,name:"beta_schedule"},{anchor:"diffusers.LMSDiscreteScheduler.trained_betas",description:`<strong>trained_betas</strong> (<code>np.ndarray</code>, optional) &#x2014;
option to pass an array of betas directly to the constructor to bypass <code>beta_start</code>, <code>beta_end</code> etc.`,name:"trained_betas"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_lms_discrete.py#L47"}}),Rs=new b({props:{name:"get_lms_coefficient",anchor:"diffusers.LMSDiscreteScheduler.get_lms_coefficient",parameters:[{name:"order",val:""},{name:"t",val:""},{name:"current_order",val:""}],parametersDescription:[{anchor:"diffusers.LMSDiscreteScheduler.get_lms_coefficient.order",description:"<strong>order</strong> (TODO) &#x2014;",name:"order"},{anchor:"diffusers.LMSDiscreteScheduler.get_lms_coefficient.t",description:"<strong>t</strong> (TODO) &#x2014;",name:"t"},{anchor:"diffusers.LMSDiscreteScheduler.get_lms_coefficient.current_order",description:"<strong>current_order</strong> (TODO) &#x2014;",name:"current_order"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_lms_discrete.py#L138"}}),Qs=new b({props:{name:"scale_model_input",anchor:"diffusers.LMSDiscreteScheduler.scale_model_input",parameters:[{name:"sample",val:": FloatTensor"},{name:"timestep",val:": typing.Union[float, torch.FloatTensor]"}],parametersDescription:[{anchor:"diffusers.LMSDiscreteScheduler.scale_model_input.sample",description:"<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014; input sample",name:"sample"},{anchor:"diffusers.LMSDiscreteScheduler.scale_model_input.timestep",description:"<strong>timestep</strong> (<code>float</code> or <code>torch.FloatTensor</code>) &#x2014; the current timestep in the diffusion chain",name:"timestep"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_lms_discrete.py#L117",returnDescription:`
<p>scaled input sample</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),Ws=new b({props:{name:"set_timesteps",anchor:"diffusers.LMSDiscreteScheduler.set_timesteps",parameters:[{name:"num_inference_steps",val:": int"},{name:"device",val:": typing.Union[str, torch.device] = None"}],parametersDescription:[{anchor:"diffusers.LMSDiscreteScheduler.set_timesteps.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>) &#x2014;
the number of diffusion steps used when generating samples with a pre-trained model.`,name:"num_inference_steps"},{anchor:"diffusers.LMSDiscreteScheduler.set_timesteps.device",description:`<strong>device</strong> (<code>str</code> or <code>torch.device</code>, optional) &#x2014;
the device to which the timesteps should be moved to. If <code>None</code>, the timesteps are not moved.`,name:"device"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_lms_discrete.py#L160"}}),Us=new b({props:{name:"step",anchor:"diffusers.LMSDiscreteScheduler.step",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": typing.Union[float, torch.FloatTensor]"},{name:"sample",val:": FloatTensor"},{name:"order",val:": int = 4"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.LMSDiscreteScheduler.step.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.LMSDiscreteScheduler.step.timestep",description:"<strong>timestep</strong> (<code>float</code>) &#x2014; current timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.LMSDiscreteScheduler.step.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.
order &#x2014; coefficient for multi-step inference.`,name:"sample"},{anchor:"diffusers.LMSDiscreteScheduler.step.return_dict",description:"<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than LMSDiscreteSchedulerOutput class",name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_lms_discrete.py#L186",returnDescription:`
<p><code>~schedulers.scheduling_utils.LMSDiscreteSchedulerOutput</code> if <code>return_dict</code> is True, otherwise a <code>tuple</code>.
When returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>~schedulers.scheduling_utils.LMSDiscreteSchedulerOutput</code> or <code>tuple</code></p>
`}}),Bs=new w({}),Gs=new b({props:{name:"class diffusers.PNDMScheduler",anchor:"diffusers.PNDMScheduler",parameters:[{name:"num_train_timesteps",val:": int = 1000"},{name:"beta_start",val:": float = 0.0001"},{name:"beta_end",val:": float = 0.02"},{name:"beta_schedule",val:": str = 'linear'"},{name:"trained_betas",val:": typing.Optional[numpy.ndarray] = None"},{name:"skip_prk_steps",val:": bool = False"},{name:"set_alpha_to_one",val:": bool = False"},{name:"steps_offset",val:": int = 0"}],parametersDescription:[{anchor:"diffusers.PNDMScheduler.num_train_timesteps",description:"<strong>num_train_timesteps</strong> (<code>int</code>) &#x2014; number of diffusion steps used to train the model.",name:"num_train_timesteps"},{anchor:"diffusers.PNDMScheduler.beta_start",description:"<strong>beta_start</strong> (<code>float</code>) &#x2014; the starting <code>beta</code> value of inference.",name:"beta_start"},{anchor:"diffusers.PNDMScheduler.beta_end",description:"<strong>beta_end</strong> (<code>float</code>) &#x2014; the final <code>beta</code> value.",name:"beta_end"},{anchor:"diffusers.PNDMScheduler.beta_schedule",description:`<strong>beta_schedule</strong> (<code>str</code>) &#x2014;
the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
<code>linear</code>, <code>scaled_linear</code>, or <code>squaredcos_cap_v2</code>.`,name:"beta_schedule"},{anchor:"diffusers.PNDMScheduler.trained_betas",description:`<strong>trained_betas</strong> (<code>np.ndarray</code>, optional) &#x2014;
option to pass an array of betas directly to the constructor to bypass <code>beta_start</code>, <code>beta_end</code> etc.`,name:"trained_betas"},{anchor:"diffusers.PNDMScheduler.skip_prk_steps",description:`<strong>skip_prk_steps</strong> (<code>bool</code>) &#x2014;
allows the scheduler to skip the Runge-Kutta steps that are defined in the original paper as being required
before plms steps; defaults to <code>False</code>.`,name:"skip_prk_steps"},{anchor:"diffusers.PNDMScheduler.set_alpha_to_one",description:`<strong>set_alpha_to_one</strong> (<code>bool</code>, default <code>False</code>) &#x2014;
each diffusion step uses the value of alphas product at that step and at the previous one. For the final
step there is no previous alpha. When this option is <code>True</code> the previous alpha product is fixed to <code>1</code>,
otherwise it uses the value of alpha at step 0.`,name:"set_alpha_to_one"},{anchor:"diffusers.PNDMScheduler.steps_offset",description:`<strong>steps_offset</strong> (<code>int</code>, default <code>0</code>) &#x2014;
an offset added to the inference steps. You can use a combination of <code>offset=1</code> and
<code>set_alpha_to_one=False</code>, to make the last step use step 0 for the previous alpha product, as done in
stable diffusion.`,name:"steps_offset"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_pndm.py#L56"}}),Ys=new b({props:{name:"scale_model_input",anchor:"diffusers.PNDMScheduler.scale_model_input",parameters:[{name:"sample",val:": FloatTensor"},{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"diffusers.PNDMScheduler.scale_model_input.sample",description:"<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014; input sample",name:"sample"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_pndm.py#L345",returnDescription:`
<p>scaled input sample</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),Js=new b({props:{name:"set_timesteps",anchor:"diffusers.PNDMScheduler.set_timesteps",parameters:[{name:"num_inference_steps",val:": int"},{name:"device",val:": typing.Union[str, torch.device] = None"}],parametersDescription:[{anchor:"diffusers.PNDMScheduler.set_timesteps.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>) &#x2014;
the number of diffusion steps used when generating samples with a pre-trained model.`,name:"num_inference_steps"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_pndm.py#L153"}}),Xs=new b({props:{name:"step",anchor:"diffusers.PNDMScheduler.step",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": int"},{name:"sample",val:": FloatTensor"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.PNDMScheduler.step.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.PNDMScheduler.step.timestep",description:"<strong>timestep</strong> (<code>int</code>) &#x2014; current discrete timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.PNDMScheduler.step.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"},{anchor:"diffusers.PNDMScheduler.step.return_dict",description:"<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than SchedulerOutput class",name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_pndm.py#L192",returnDescription:`
<p><a
  href="/docs/diffusers/pr_1116/en/api/schedulers#diffusers.schedulers.scheduling_utils.SchedulerOutput"
>SchedulerOutput</a> if <code>return_dict</code> is True, otherwise a <code>tuple</code>. When
returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><a
  href="/docs/diffusers/pr_1116/en/api/schedulers#diffusers.schedulers.scheduling_utils.SchedulerOutput"
>SchedulerOutput</a> or <code>tuple</code></p>
`}}),Zs=new b({props:{name:"step_plms",anchor:"diffusers.PNDMScheduler.step_plms",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": int"},{name:"sample",val:": FloatTensor"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.PNDMScheduler.step_plms.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.PNDMScheduler.step_plms.timestep",description:"<strong>timestep</strong> (<code>int</code>) &#x2014; current discrete timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.PNDMScheduler.step_plms.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"},{anchor:"diffusers.PNDMScheduler.step_plms.return_dict",description:"<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than SchedulerOutput class",name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_pndm.py#L278",returnDescription:`
<p><code>~scheduling_utils.SchedulerOutput</code> if <code>return_dict</code> is
True, otherwise a <code>tuple</code>. When returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>~scheduling_utils.SchedulerOutput</code> or <code>tuple</code></p>
`}}),eo=new b({props:{name:"step_prk",anchor:"diffusers.PNDMScheduler.step_prk",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": int"},{name:"sample",val:": FloatTensor"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.PNDMScheduler.step_prk.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.PNDMScheduler.step_prk.timestep",description:"<strong>timestep</strong> (<code>int</code>) &#x2014; current discrete timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.PNDMScheduler.step_prk.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"},{anchor:"diffusers.PNDMScheduler.step_prk.return_dict",description:"<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than SchedulerOutput class",name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_pndm.py#L223",returnDescription:`
<p><code>~scheduling_utils.SchedulerOutput</code> if <code>return_dict</code> is
True, otherwise a <code>tuple</code>. When returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>~scheduling_utils.SchedulerOutput</code> or <code>tuple</code></p>
`}}),to=new w({}),so=new b({props:{name:"class diffusers.ScoreSdeVeScheduler",anchor:"diffusers.ScoreSdeVeScheduler",parameters:[{name:"num_train_timesteps",val:": int = 2000"},{name:"snr",val:": float = 0.15"},{name:"sigma_min",val:": float = 0.01"},{name:"sigma_max",val:": float = 1348.0"},{name:"sampling_eps",val:": float = 1e-05"},{name:"correct_steps",val:": int = 1"}],parametersDescription:[{anchor:"diffusers.ScoreSdeVeScheduler.num_train_timesteps",description:"<strong>num_train_timesteps</strong> (<code>int</code>) &#x2014; number of diffusion steps used to train the model.",name:"num_train_timesteps"},{anchor:"diffusers.ScoreSdeVeScheduler.snr",description:`<strong>snr</strong> (<code>float</code>) &#x2014;
coefficient weighting the step from the model_output sample (from the network) to the random noise.`,name:"snr"},{anchor:"diffusers.ScoreSdeVeScheduler.sigma_min",description:`<strong>sigma_min</strong> (<code>float</code>) &#x2014;
initial noise scale for sigma sequence in sampling procedure. The minimum sigma should mirror the
distribution of the data.`,name:"sigma_min"},{anchor:"diffusers.ScoreSdeVeScheduler.sigma_max",description:"<strong>sigma_max</strong> (<code>float</code>) &#x2014; maximum value used for the range of continuous timesteps passed into the model.",name:"sigma_max"},{anchor:"diffusers.ScoreSdeVeScheduler.sampling_eps",description:`<strong>sampling_eps</strong> (<code>float</code>) &#x2014; the end value of sampling, where timesteps decrease progressively from 1 to
epsilon. &#x2014;`,name:"sampling_eps"},{anchor:"diffusers.ScoreSdeVeScheduler.correct_steps",description:"<strong>correct_steps</strong> (<code>int</code>) &#x2014; number of correction steps performed on a produced sample.",name:"correct_steps"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_sde_ve.py#L45"}}),no=new b({props:{name:"scale_model_input",anchor:"diffusers.ScoreSdeVeScheduler.scale_model_input",parameters:[{name:"sample",val:": FloatTensor"},{name:"timestep",val:": typing.Optional[int] = None"}],parametersDescription:[{anchor:"diffusers.ScoreSdeVeScheduler.scale_model_input.sample",description:"<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014; input sample",name:"sample"},{anchor:"diffusers.ScoreSdeVeScheduler.scale_model_input.timestep",description:"<strong>timestep</strong> (<code>int</code>, optional) &#x2014; current timestep",name:"timestep"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_sde_ve.py#L87",returnDescription:`
<p>scaled input sample</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),io=new b({props:{name:"set_sigmas",anchor:"diffusers.ScoreSdeVeScheduler.set_sigmas",parameters:[{name:"num_inference_steps",val:": int"},{name:"sigma_min",val:": float = None"},{name:"sigma_max",val:": float = None"},{name:"sampling_eps",val:": float = None"}],parametersDescription:[{anchor:"diffusers.ScoreSdeVeScheduler.set_sigmas.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>) &#x2014;
the number of diffusion steps used when generating samples with a pre-trained model.`,name:"num_inference_steps"},{anchor:"diffusers.ScoreSdeVeScheduler.set_sigmas.sigma_min",description:`<strong>sigma_min</strong> (<code>float</code>, optional) &#x2014;
initial noise scale value (overrides value given at Scheduler instantiation).`,name:"sigma_min"},{anchor:"diffusers.ScoreSdeVeScheduler.set_sigmas.sigma_max",description:"<strong>sigma_max</strong> (<code>float</code>, optional) &#x2014; final noise scale value (overrides value given at Scheduler instantiation).",name:"sigma_max"},{anchor:"diffusers.ScoreSdeVeScheduler.set_sigmas.sampling_eps",description:"<strong>sampling_eps</strong> (<code>float</code>, optional) &#x2014; final timestep value (overrides value given at Scheduler instantiation).",name:"sampling_eps"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_sde_ve.py#L117"}}),ao=new b({props:{name:"set_timesteps",anchor:"diffusers.ScoreSdeVeScheduler.set_timesteps",parameters:[{name:"num_inference_steps",val:": int"},{name:"sampling_eps",val:": float = None"},{name:"device",val:": typing.Union[str, torch.device] = None"}],parametersDescription:[{anchor:"diffusers.ScoreSdeVeScheduler.set_timesteps.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>) &#x2014;
the number of diffusion steps used when generating samples with a pre-trained model.`,name:"num_inference_steps"},{anchor:"diffusers.ScoreSdeVeScheduler.set_timesteps.sampling_eps",description:"<strong>sampling_eps</strong> (<code>float</code>, optional) &#x2014; final timestep value (overrides value given at Scheduler instantiation).",name:"sampling_eps"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_sde_ve.py#L101"}}),lo=new b({props:{name:"step_correct",anchor:"diffusers.ScoreSdeVeScheduler.step_correct",parameters:[{name:"model_output",val:": FloatTensor"},{name:"sample",val:": FloatTensor"},{name:"generator",val:": typing.Optional[torch._C.Generator] = None"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.ScoreSdeVeScheduler.step_correct.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.ScoreSdeVeScheduler.step_correct.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.
generator &#x2014; random number generator.`,name:"sample"},{anchor:"diffusers.ScoreSdeVeScheduler.step_correct.return_dict",description:"<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than SchedulerOutput class",name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_sde_ve.py#L212",returnDescription:`
<p><code>SdeVeOutput</code> if
<code>return_dict</code> is True, otherwise a <code>tuple</code>. When returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>SdeVeOutput</code> or <code>tuple</code></p>
`}}),co=new b({props:{name:"step_pred",anchor:"diffusers.ScoreSdeVeScheduler.step_pred",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": int"},{name:"sample",val:": FloatTensor"},{name:"generator",val:": typing.Optional[torch._C.Generator] = None"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.ScoreSdeVeScheduler.step_pred.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.ScoreSdeVeScheduler.step_pred.timestep",description:"<strong>timestep</strong> (<code>int</code>) &#x2014; current discrete timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.ScoreSdeVeScheduler.step_pred.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.
generator &#x2014; random number generator.`,name:"sample"},{anchor:"diffusers.ScoreSdeVeScheduler.step_pred.return_dict",description:"<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than SchedulerOutput class",name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_sde_ve.py#L151",returnDescription:`
<p><code>SdeVeOutput</code> if
<code>return_dict</code> is True, otherwise a <code>tuple</code>. When returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>SdeVeOutput</code> or <code>tuple</code></p>
`}}),uo=new w({}),fo=new b({props:{name:"class diffusers.IPNDMScheduler",anchor:"diffusers.IPNDMScheduler",parameters:[{name:"num_train_timesteps",val:": int = 1000"}],parametersDescription:[{anchor:"diffusers.IPNDMScheduler.num_train_timesteps",description:"<strong>num_train_timesteps</strong> (<code>int</code>) &#x2014; number of diffusion steps used to train the model.",name:"num_train_timesteps"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_ipndm.py#L24"}}),go=new b({props:{name:"scale_model_input",anchor:"diffusers.IPNDMScheduler.scale_model_input",parameters:[{name:"sample",val:": FloatTensor"},{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"diffusers.IPNDMScheduler.scale_model_input.sample",description:"<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014; input sample",name:"sample"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_ipndm.py#L126",returnDescription:`
<p>scaled input sample</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),_o=new b({props:{name:"set_timesteps",anchor:"diffusers.IPNDMScheduler.set_timesteps",parameters:[{name:"num_inference_steps",val:": int"},{name:"device",val:": typing.Union[str, torch.device] = None"}],parametersDescription:[{anchor:"diffusers.IPNDMScheduler.set_timesteps.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>) &#x2014;
the number of diffusion steps used when generating samples with a pre-trained model.`,name:"num_inference_steps"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_ipndm.py#L56"}}),vo=new b({props:{name:"step",anchor:"diffusers.IPNDMScheduler.step",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": int"},{name:"sample",val:": FloatTensor"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.IPNDMScheduler.step.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.IPNDMScheduler.step.timestep",description:"<strong>timestep</strong> (<code>int</code>) &#x2014; current discrete timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.IPNDMScheduler.step.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"},{anchor:"diffusers.IPNDMScheduler.step.return_dict",description:"<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than SchedulerOutput class",name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_ipndm.py#L76",returnDescription:`
<p><code>~scheduling_utils.SchedulerOutput</code> if <code>return_dict</code> is
True, otherwise a <code>tuple</code>. When returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>~scheduling_utils.SchedulerOutput</code> or <code>tuple</code></p>
`}}),bo=new w({}),gr=new Q5({props:{warning:!0,$$slots:{default:[j5]},$$scope:{ctx:tc}}}),Do=new b({props:{name:"class diffusers.schedulers.ScoreSdeVpScheduler",anchor:"diffusers.schedulers.ScoreSdeVpScheduler",parameters:[{name:"num_train_timesteps",val:" = 2000"},{name:"beta_min",val:" = 0.1"},{name:"beta_max",val:" = 20"},{name:"sampling_eps",val:" = 0.001"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_sde_vp.py#L26"}}),$o=new w({}),wo=new b({props:{name:"class diffusers.EulerDiscreteScheduler",anchor:"diffusers.EulerDiscreteScheduler",parameters:[{name:"num_train_timesteps",val:": int = 1000"},{name:"beta_start",val:": float = 0.0001"},{name:"beta_end",val:": float = 0.02"},{name:"beta_schedule",val:": str = 'linear'"},{name:"trained_betas",val:": typing.Optional[numpy.ndarray] = None"}],parametersDescription:[{anchor:"diffusers.EulerDiscreteScheduler.num_train_timesteps",description:"<strong>num_train_timesteps</strong> (<code>int</code>) &#x2014; number of diffusion steps used to train the model.",name:"num_train_timesteps"},{anchor:"diffusers.EulerDiscreteScheduler.beta_start",description:"<strong>beta_start</strong> (<code>float</code>) &#x2014; the starting <code>beta</code> value of inference.",name:"beta_start"},{anchor:"diffusers.EulerDiscreteScheduler.beta_end",description:"<strong>beta_end</strong> (<code>float</code>) &#x2014; the final <code>beta</code> value.",name:"beta_end"},{anchor:"diffusers.EulerDiscreteScheduler.beta_schedule",description:`<strong>beta_schedule</strong> (<code>str</code>) &#x2014;
the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
<code>linear</code> or <code>scaled_linear</code>.`,name:"beta_schedule"},{anchor:"diffusers.EulerDiscreteScheduler.trained_betas",description:`<strong>trained_betas</strong> (<code>np.ndarray</code>, optional) &#x2014;
option to pass an array of betas directly to the constructor to bypass <code>beta_start</code>, <code>beta_end</code> etc.`,name:"trained_betas"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_euler_discrete.py#L48"}}),To=new b({props:{name:"scale_model_input",anchor:"diffusers.EulerDiscreteScheduler.scale_model_input",parameters:[{name:"sample",val:": FloatTensor"},{name:"timestep",val:": typing.Union[float, torch.FloatTensor]"}],parametersDescription:[{anchor:"diffusers.EulerDiscreteScheduler.scale_model_input.sample",description:"<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014; input sample",name:"sample"},{anchor:"diffusers.EulerDiscreteScheduler.scale_model_input.timestep",description:"<strong>timestep</strong> (<code>float</code> or <code>torch.FloatTensor</code>) &#x2014; the current timestep in the diffusion chain",name:"timestep"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_euler_discrete.py#L117",returnDescription:`
<p>scaled input sample</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),ko=new b({props:{name:"set_timesteps",anchor:"diffusers.EulerDiscreteScheduler.set_timesteps",parameters:[{name:"num_inference_steps",val:": int"},{name:"device",val:": typing.Union[str, torch.device] = None"}],parametersDescription:[{anchor:"diffusers.EulerDiscreteScheduler.set_timesteps.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>) &#x2014;
the number of diffusion steps used when generating samples with a pre-trained model.`,name:"num_inference_steps"},{anchor:"diffusers.EulerDiscreteScheduler.set_timesteps.device",description:`<strong>device</strong> (<code>str</code> or <code>torch.device</code>, optional) &#x2014;
the device to which the timesteps should be moved to. If <code>None</code>, the timesteps are not moved.`,name:"device"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_euler_discrete.py#L138"}}),Oo=new b({props:{name:"step",anchor:"diffusers.EulerDiscreteScheduler.step",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": typing.Union[float, torch.FloatTensor]"},{name:"sample",val:": FloatTensor"},{name:"s_churn",val:": float = 0.0"},{name:"s_tmin",val:": float = 0.0"},{name:"s_tmax",val:": float = inf"},{name:"s_noise",val:": float = 1.0"},{name:"generator",val:": typing.Optional[torch._C.Generator] = None"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.EulerDiscreteScheduler.step.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.EulerDiscreteScheduler.step.timestep",description:"<strong>timestep</strong> (<code>float</code>) &#x2014; current timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.EulerDiscreteScheduler.step.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"},{anchor:"diffusers.EulerDiscreteScheduler.step.s_churn",description:"<strong>s_churn</strong> (<code>float</code>) &#x2014;",name:"s_churn"},{anchor:"diffusers.EulerDiscreteScheduler.step.s_tmin",description:"<strong>s_tmin</strong>  (<code>float</code>) &#x2014;",name:"s_tmin"},{anchor:"diffusers.EulerDiscreteScheduler.step.s_tmax",description:"<strong>s_tmax</strong>  (<code>float</code>) &#x2014;",name:"s_tmax"},{anchor:"diffusers.EulerDiscreteScheduler.step.s_noise",description:"<strong>s_noise</strong> (<code>float</code>) &#x2014;",name:"s_noise"},{anchor:"diffusers.EulerDiscreteScheduler.step.generator",description:"<strong>generator</strong> (<code>torch.Generator</code>, optional) &#x2014; Random number generator.",name:"generator"},{anchor:"diffusers.EulerDiscreteScheduler.step.return_dict",description:"<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than EulerDiscreteSchedulerOutput class",name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_euler_discrete.py#L161",returnDescription:`
<p><code>~schedulers.scheduling_utils.EulerDiscreteSchedulerOutput</code> if <code>return_dict</code> is True, otherwise a
<code>tuple</code>. When returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>~schedulers.scheduling_utils.EulerDiscreteSchedulerOutput</code> or <code>tuple</code></p>
`}}),Ao=new w({}),Vo=new b({props:{name:"class diffusers.EulerAncestralDiscreteScheduler",anchor:"diffusers.EulerAncestralDiscreteScheduler",parameters:[{name:"num_train_timesteps",val:": int = 1000"},{name:"beta_start",val:": float = 0.0001"},{name:"beta_end",val:": float = 0.02"},{name:"beta_schedule",val:": str = 'linear'"},{name:"trained_betas",val:": typing.Optional[numpy.ndarray] = None"}],parametersDescription:[{anchor:"diffusers.EulerAncestralDiscreteScheduler.num_train_timesteps",description:"<strong>num_train_timesteps</strong> (<code>int</code>) &#x2014; number of diffusion steps used to train the model.",name:"num_train_timesteps"},{anchor:"diffusers.EulerAncestralDiscreteScheduler.beta_start",description:"<strong>beta_start</strong> (<code>float</code>) &#x2014; the starting <code>beta</code> value of inference.",name:"beta_start"},{anchor:"diffusers.EulerAncestralDiscreteScheduler.beta_end",description:"<strong>beta_end</strong> (<code>float</code>) &#x2014; the final <code>beta</code> value.",name:"beta_end"},{anchor:"diffusers.EulerAncestralDiscreteScheduler.beta_schedule",description:`<strong>beta_schedule</strong> (<code>str</code>) &#x2014;
the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
<code>linear</code> or <code>scaled_linear</code>.`,name:"beta_schedule"},{anchor:"diffusers.EulerAncestralDiscreteScheduler.trained_betas",description:`<strong>trained_betas</strong> (<code>np.ndarray</code>, optional) &#x2014;
option to pass an array of betas directly to the constructor to bypass <code>beta_start</code>, <code>beta_end</code> etc.`,name:"trained_betas"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_euler_ancestral_discrete.py#L48"}}),Io=new b({props:{name:"scale_model_input",anchor:"diffusers.EulerAncestralDiscreteScheduler.scale_model_input",parameters:[{name:"sample",val:": FloatTensor"},{name:"timestep",val:": typing.Union[float, torch.FloatTensor]"}],parametersDescription:[{anchor:"diffusers.EulerAncestralDiscreteScheduler.scale_model_input.sample",description:"<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014; input sample",name:"sample"},{anchor:"diffusers.EulerAncestralDiscreteScheduler.scale_model_input.timestep",description:"<strong>timestep</strong> (<code>float</code> or <code>torch.FloatTensor</code>) &#x2014; the current timestep in the diffusion chain",name:"timestep"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_euler_ancestral_discrete.py#L116",returnDescription:`
<p>scaled input sample</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),Lo=new b({props:{name:"set_timesteps",anchor:"diffusers.EulerAncestralDiscreteScheduler.set_timesteps",parameters:[{name:"num_inference_steps",val:": int"},{name:"device",val:": typing.Union[str, torch.device] = None"}],parametersDescription:[{anchor:"diffusers.EulerAncestralDiscreteScheduler.set_timesteps.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>) &#x2014;
the number of diffusion steps used when generating samples with a pre-trained model.`,name:"num_inference_steps"},{anchor:"diffusers.EulerAncestralDiscreteScheduler.set_timesteps.device",description:`<strong>device</strong> (<code>str</code> or <code>torch.device</code>, optional) &#x2014;
the device to which the timesteps should be moved to. If <code>None</code>, the timesteps are not moved.`,name:"device"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_euler_ancestral_discrete.py#L137"}}),qo=new b({props:{name:"step",anchor:"diffusers.EulerAncestralDiscreteScheduler.step",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": typing.Union[float, torch.FloatTensor]"},{name:"sample",val:": FloatTensor"},{name:"generator",val:": typing.Optional[torch._C.Generator] = None"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.EulerAncestralDiscreteScheduler.step.model_output",description:"<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned diffusion model.",name:"model_output"},{anchor:"diffusers.EulerAncestralDiscreteScheduler.step.timestep",description:"<strong>timestep</strong> (<code>float</code>) &#x2014; current timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.EulerAncestralDiscreteScheduler.step.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"},{anchor:"diffusers.EulerAncestralDiscreteScheduler.step.generator",description:"<strong>generator</strong> (<code>torch.Generator</code>, optional) &#x2014; Random number generator.",name:"generator"},{anchor:"diffusers.EulerAncestralDiscreteScheduler.step.return_dict",description:"<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than EulerAncestralDiscreteSchedulerOutput class",name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_euler_ancestral_discrete.py#L160",returnDescription:`
<p><code>~schedulers.scheduling_utils.EulerAncestralDiscreteSchedulerOutput</code> if <code>return_dict</code> is True, otherwise
a <code>tuple</code>. When returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>~schedulers.scheduling_utils.EulerAncestralDiscreteSchedulerOutput</code> or <code>tuple</code></p>
`}}),Ko=new w({}),jo=new b({props:{name:"class diffusers.VQDiffusionScheduler",anchor:"diffusers.VQDiffusionScheduler",parameters:[{name:"num_vec_classes",val:": int"},{name:"num_train_timesteps",val:": int = 100"},{name:"alpha_cum_start",val:": float = 0.99999"},{name:"alpha_cum_end",val:": float = 9e-06"},{name:"gamma_cum_start",val:": float = 9e-06"},{name:"gamma_cum_end",val:": float = 0.99999"}],parametersDescription:[{anchor:"diffusers.VQDiffusionScheduler.num_vec_classes",description:`<strong>num_vec_classes</strong> (<code>int</code>) &#x2014;
The number of classes of the vector embeddings of the latent pixels. Includes the class for the masked
latent pixel.`,name:"num_vec_classes"},{anchor:"diffusers.VQDiffusionScheduler.num_train_timesteps",description:`<strong>num_train_timesteps</strong> (<code>int</code>) &#x2014;
Number of diffusion steps used to train the model.`,name:"num_train_timesteps"},{anchor:"diffusers.VQDiffusionScheduler.alpha_cum_start",description:`<strong>alpha_cum_start</strong> (<code>float</code>) &#x2014;
The starting cumulative alpha value.`,name:"alpha_cum_start"},{anchor:"diffusers.VQDiffusionScheduler.alpha_cum_end",description:`<strong>alpha_cum_end</strong> (<code>float</code>) &#x2014;
The ending cumulative alpha value.`,name:"alpha_cum_end"},{anchor:"diffusers.VQDiffusionScheduler.gamma_cum_start",description:`<strong>gamma_cum_start</strong> (<code>float</code>) &#x2014;
The starting cumulative gamma value.`,name:"gamma_cum_start"},{anchor:"diffusers.VQDiffusionScheduler.gamma_cum_end",description:`<strong>gamma_cum_end</strong> (<code>float</code>) &#x2014;
The ending cumulative gamma value.`,name:"gamma_cum_end"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_vq_diffusion.py#L106"}}),Uo=new b({props:{name:"log_Q_t_transitioning_to_known_class",anchor:"diffusers.VQDiffusionScheduler.log_Q_t_transitioning_to_known_class",parameters:[{name:"t",val:": torch.int32"},{name:"x_t",val:": LongTensor"},{name:"log_onehot_x_t",val:": FloatTensor"},{name:"cumulative",val:": bool"}],parametersDescription:[{anchor:"diffusers.VQDiffusionScheduler.log_Q_t_transitioning_to_known_class.t",description:`<strong>t</strong> (torch.Long) &#x2014;
The timestep that determines which transition matrix is used.`,name:"t"},{anchor:"diffusers.VQDiffusionScheduler.log_Q_t_transitioning_to_known_class.x_t",description:`<strong>x_t</strong> (<code>torch.LongTensor</code> of shape <code>(batch size, num latent pixels)</code>) &#x2014;
The classes of each latent pixel at time <code>t</code>.`,name:"x_t"},{anchor:"diffusers.VQDiffusionScheduler.log_Q_t_transitioning_to_known_class.log_onehot_x_t",description:`<strong>log_onehot_x_t</strong> (<code>torch.FloatTensor</code> of shape <code>(batch size, num classes, num latent pixels)</code>) &#x2014;
The log one-hot vectors of <code>x_t</code>`,name:"log_onehot_x_t"},{anchor:"diffusers.VQDiffusionScheduler.log_Q_t_transitioning_to_known_class.cumulative",description:`<strong>cumulative</strong> (<code>bool</code>) &#x2014;
If cumulative is <code>False</code>, we use the single step transition matrix <code>t-1</code>-&gt;<code>t</code>. If cumulative is <code>True</code>,
we use the cumulative transition matrix <code>0</code>-&gt;<code>t</code>.`,name:"cumulative"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_vq_diffusion.py#L377",returnDescription:`
<p>Each <em>column</em> of the returned matrix is a <em>row</em> of log probabilities of the complete probability
transition matrix.</p>
<p>When non cumulative, returns <code>self.num_classes - 1</code> rows because the initial latent pixel cannot be
masked.</p>
<p>Where:</p>
<ul>
<li><code>q_n</code> is the probability distribution for the forward process of the <code>n</code>th latent pixel.</li>
<li>C_0 is a class of a latent pixel embedding</li>
<li>C_k is the class of the masked latent pixel</li>
</ul>
<p>non-cumulative result (omitting logarithms):</p>

	<CodeBlock 
		code={\`q_0(x_t | x_{t-1\\} = C_0) ... q_n(x_t | x_{t-1\\} = C_0)
          .      .                     .
          .               .            .
          .                      .     .
q_0(x_t | x_{t-1\\} = C_k) ... q_n(x_t | x_{t-1\\} = C_k)\`}
		highlighted={\`q<span class="hljs-constructor">_0(<span class="hljs-params">x_t</span> | <span class="hljs-params">x_</span>{<span class="hljs-params">t</span>-1\\} = C_0)</span><span class="hljs-operator"> ... </span>q<span class="hljs-constructor">_n(<span class="hljs-params">x_t</span> | <span class="hljs-params">x_</span>{<span class="hljs-params">t</span>-1\\} = C_0)</span>
          .      .                     .
          .               .            .
          .                      .     .
q<span class="hljs-constructor">_0(<span class="hljs-params">x_t</span> | <span class="hljs-params">x_</span>{<span class="hljs-params">t</span>-1\\} = C_k)</span><span class="hljs-operator"> ... </span>q<span class="hljs-constructor">_n(<span class="hljs-params">x_t</span> | <span class="hljs-params">x_</span>{<span class="hljs-params">t</span>-1\\} = C_k)</span>\`}
	/>
<p>cumulative result (omitting logarithms):</p>

	<CodeBlock 
		code={\`q_0_cumulative(x_t | x_0 = C_0)    ...  q_n_cumulative(x_t | x_0 = C_0)
          .               .                          .
          .                        .                 .
          .                               .          .
q_0_cumulative(x_t | x_0 = C_{k-1\\}) ... q_n_cumulative(x_t | x_0 = C_{k-1\\})\`}
		highlighted={\`q<span class="hljs-constructor">_0_cumulative(<span class="hljs-params">x_t</span> | <span class="hljs-params">x_0</span> = C_0)</span><span class="hljs-operator">    ...  </span>q<span class="hljs-constructor">_n_cumulative(<span class="hljs-params">x_t</span> | <span class="hljs-params">x_0</span> = C_0)</span>
          .               .                          .
          .                        .                 .
          .                               .          .
q<span class="hljs-constructor">_0_cumulative(<span class="hljs-params">x_t</span> | <span class="hljs-params">x_0</span> = C_{<span class="hljs-params">k</span>-1\\})</span><span class="hljs-operator"> ... </span>q<span class="hljs-constructor">_n_cumulative(<span class="hljs-params">x_t</span> | <span class="hljs-params">x_0</span> = C_{<span class="hljs-params">k</span>-1\\})</span>\`}
	/>
`,returnType:`
<p><code>torch.FloatTensor</code> of shape <code>(batch size, num classes - 1, num latent pixels)</code></p>
`}}),Ho=new b({props:{name:"q_posterior",anchor:"diffusers.VQDiffusionScheduler.q_posterior",parameters:[{name:"log_p_x_0",val:""},{name:"x_t",val:""},{name:"t",val:""}],parametersDescription:[{anchor:"diffusers.VQDiffusionScheduler.q_posterior.t",description:`<strong>t</strong> (torch.Long) &#x2014;
The timestep that determines which transition matrix is used.`,name:"t"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_vq_diffusion.py#L258",returnDescription:`
<p>The log probabilities for the predicted classes of the image at timestep <code>t-1</code>. I.e. Equation (11).</p>
`,returnType:`
<p><code>torch.FloatTensor</code> of shape <code>(batch size, num classes, num latent pixels)</code></p>
`}}),Yo=new b({props:{name:"set_timesteps",anchor:"diffusers.VQDiffusionScheduler.set_timesteps",parameters:[{name:"num_inference_steps",val:": int"},{name:"device",val:": typing.Union[str, torch.device] = None"}],parametersDescription:[{anchor:"diffusers.VQDiffusionScheduler.set_timesteps.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>) &#x2014;
the number of diffusion steps used when generating samples with a pre-trained model.`,name:"num_inference_steps"},{anchor:"diffusers.VQDiffusionScheduler.set_timesteps.device",description:`<strong>device</strong> (<code>str</code> or <code>torch.device</code>) &#x2014;
device to place the timesteps and the diffusion process parameters (alpha, beta, gamma) on.`,name:"device"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_vq_diffusion.py#L188"}}),Jo=new b({props:{name:"step",anchor:"diffusers.VQDiffusionScheduler.step",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": torch.int64"},{name:"sample",val:": LongTensor"},{name:"generator",val:": typing.Optional[torch._C.Generator] = None"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.VQDiffusionScheduler.step.t",description:`<strong>t</strong> (<code>torch.long</code>) &#x2014;
The timestep that determines which transition matrices are used.</p>
<p>x_t &#x2014; (<code>torch.LongTensor</code> of shape <code>(batch size, num latent pixels)</code>):
The classes of each latent pixel at time <code>t</code></p>
<p>generator &#x2014; (<code>torch.Generator</code> or None):
RNG for the noise applied to p(x_{t-1} | x_t) before it is sampled from.`,name:"t"},{anchor:"diffusers.VQDiffusionScheduler.step.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>) &#x2014;
option for returning tuple rather than VQDiffusionSchedulerOutput class`,name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_vq_diffusion.py#L210",returnDescription:`
<p><code>~schedulers.scheduling_utils.VQDiffusionSchedulerOutput</code> if <code>return_dict</code> is True, otherwise a <code>tuple</code>.
When returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>~schedulers.scheduling_utils.VQDiffusionSchedulerOutput</code> or <code>tuple</code></p>
`}}),Zo=new w({}),rn=new b({props:{name:"class diffusers.RePaintScheduler",anchor:"diffusers.RePaintScheduler",parameters:[{name:"num_train_timesteps",val:": int = 1000"},{name:"beta_start",val:": float = 0.0001"},{name:"beta_end",val:": float = 0.02"},{name:"beta_schedule",val:": str = 'linear'"},{name:"eta",val:": float = 0.0"},{name:"trained_betas",val:": typing.Optional[numpy.ndarray] = None"},{name:"clip_sample",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.RePaintScheduler.num_train_timesteps",description:"<strong>num_train_timesteps</strong> (<code>int</code>) &#x2014; number of diffusion steps used to train the model.",name:"num_train_timesteps"},{anchor:"diffusers.RePaintScheduler.beta_start",description:"<strong>beta_start</strong> (<code>float</code>) &#x2014; the starting <code>beta</code> value of inference.",name:"beta_start"},{anchor:"diffusers.RePaintScheduler.beta_end",description:"<strong>beta_end</strong> (<code>float</code>) &#x2014; the final <code>beta</code> value.",name:"beta_end"},{anchor:"diffusers.RePaintScheduler.beta_schedule",description:`<strong>beta_schedule</strong> (<code>str</code>) &#x2014;
the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
<code>linear</code>, <code>scaled_linear</code>, or <code>squaredcos_cap_v2</code>.`,name:"beta_schedule"},{anchor:"diffusers.RePaintScheduler.eta",description:`<strong>eta</strong> (<code>float</code>) &#x2014;
The weight of noise for added noise in a diffusion step. Its value is between 0.0 and 1.0 -0.0 is DDIM and
1.0 is DDPM scheduler respectively.`,name:"eta"},{anchor:"diffusers.RePaintScheduler.trained_betas",description:`<strong>trained_betas</strong> (<code>np.ndarray</code>, optional) &#x2014;
option to pass an array of betas directly to the constructor to bypass <code>beta_start</code>, <code>beta_end</code> etc.`,name:"trained_betas"},{anchor:"diffusers.RePaintScheduler.variance_type",description:`<strong>variance_type</strong> (<code>str</code>) &#x2014;
options to clip the variance used when adding noise to the denoised sample. Choose from <code>fixed_small</code>,
<code>fixed_small_log</code>, <code>fixed_large</code>, <code>fixed_large_log</code>, <code>learned</code> or <code>learned_range</code>.`,name:"variance_type"},{anchor:"diffusers.RePaintScheduler.clip_sample",description:`<strong>clip_sample</strong> (<code>bool</code>, default <code>True</code>) &#x2014;
option to clip predicted sample between -1 and 1 for numerical stability.`,name:"clip_sample"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_repaint.py#L74"}}),on=new b({props:{name:"scale_model_input",anchor:"diffusers.RePaintScheduler.scale_model_input",parameters:[{name:"sample",val:": FloatTensor"},{name:"timestep",val:": typing.Optional[int] = None"}],parametersDescription:[{anchor:"diffusers.RePaintScheduler.scale_model_input.sample",description:"<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014; input sample",name:"sample"},{anchor:"diffusers.RePaintScheduler.scale_model_input.timestep",description:"<strong>timestep</strong> (<code>int</code>, optional) &#x2014; current timestep",name:"timestep"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_repaint.py#L150",returnDescription:`
<p>scaled input sample</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),nn=new b({props:{name:"step",anchor:"diffusers.RePaintScheduler.step",parameters:[{name:"model_output",val:": FloatTensor"},{name:"timestep",val:": int"},{name:"sample",val:": FloatTensor"},{name:"original_image",val:": FloatTensor"},{name:"mask",val:": FloatTensor"},{name:"generator",val:": typing.Optional[torch._C.Generator] = None"},{name:"return_dict",val:": bool = True"}],parametersDescription:[{anchor:"diffusers.RePaintScheduler.step.model_output",description:`<strong>model_output</strong> (<code>torch.FloatTensor</code>) &#x2014; direct output from learned
diffusion model.`,name:"model_output"},{anchor:"diffusers.RePaintScheduler.step.timestep",description:"<strong>timestep</strong> (<code>int</code>) &#x2014; current discrete timestep in the diffusion chain.",name:"timestep"},{anchor:"diffusers.RePaintScheduler.step.sample",description:`<strong>sample</strong> (<code>torch.FloatTensor</code>) &#x2014;
current instance of sample being created by diffusion process.`,name:"sample"},{anchor:"diffusers.RePaintScheduler.step.original_image",description:`<strong>original_image</strong> (<code>torch.FloatTensor</code>) &#x2014;
the original image to inpaint on.`,name:"original_image"},{anchor:"diffusers.RePaintScheduler.step.mask",description:`<strong>mask</strong> (<code>torch.FloatTensor</code>) &#x2014;
the mask where 0.0 values define which part of the original image to inpaint (change).`,name:"mask"},{anchor:"diffusers.RePaintScheduler.step.generator",description:"<strong>generator</strong> (<code>torch.Generator</code>, <em>optional</em>) &#x2014; random number generator.",name:"generator"},{anchor:"diffusers.RePaintScheduler.step.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>) &#x2014; option for returning tuple rather than
DDPMSchedulerOutput class`,name:"return_dict"}],source:"https://github.com/huggingface/diffusers/blob/vr_1116/src/diffusers/schedulers/scheduling_repaint.py#L213",returnDescription:`
<p><code>~schedulers.scheduling_utils.RePaintSchedulerOutput</code> if <code>return_dict</code> is True, otherwise a <code>tuple</code>. When
returning a tuple, the first element is the sample tensor.</p>
`,returnType:`
<p><code>~schedulers.scheduling_utils.RePaintSchedulerOutput</code> or <code>tuple</code></p>
`}}),{c(){Z=s("meta"),ct=l(),ee=s("h1"),De=s("a"),Ki=s("span"),f(Ir.$$.fragment),Lp=l(),Ri=s("span"),qp=i("Schedulers"),rc=l(),ln=s("p"),Kp=i("Diffusers contains multiple pre-built schedule functions for the diffusion process."),sc=l(),Le=s("h2"),ut=s("a"),Qi=s("span"),f(Nr.$$.fragment),Rp=l(),ji=s("span"),Qp=i("What is a scheduler?"),oc=l(),pt=s("p"),jp=i("The schedule functions, denoted "),Wi=s("em"),Wp=i("Schedulers"),Up=i(" in the library take in the output of a trained model, a sample which the diffusion process is iterating on, and a timestep to return a denoised sample."),nc=l(),ft=s("ul"),cn=s("li"),Bp=i("Schedulers define the methodology for iteratively adding noise to an image or for updating a sample based on model outputs."),Lr=s("ul"),Ui=s("li"),Hp=i("adding noise in different manners represent the algorithmic processes to train a diffusion model by adding noise to images."),Gp=l(),Bi=s("li"),zp=i("for inference, the scheduler defines how to update a sample based on an output from a pretrained model."),Yp=l(),qe=s("li"),Jp=i("Schedulers are often defined by a "),Hi=s("em"),Xp=i("noise schedule"),Zp=i(" and an "),Gi=s("em"),ef=i("update rule"),tf=i(" to solve the differential equation solution."),ic=l(),Ke=s("h3"),ht=s("a"),zi=s("span"),f(qr.$$.fragment),rf=l(),Yi=s("span"),sf=i("Discrete versus continuous schedulers"),ac=l(),O=s("p"),of=i(`All schedulers take in a timestep to predict the updated version of the sample being diffused.
The timesteps dictate where in the diffusion process the step is, where data is generated by iterating forward in time and inference is executed by propagating backwards through timesteps.
Different algorithms use timesteps that both discrete (accepting `),Ji=s("code"),nf=i("int"),af=i(" inputs), such as the "),un=s("a"),df=i("DDPMScheduler"),lf=i(" or "),pn=s("a"),cf=i("PNDMScheduler"),uf=i(", and continuous (accepting "),Xi=s("code"),pf=i("float"),ff=i(" inputs), such as the score-based schedulers "),fn=s("a"),hf=i("ScoreSdeVeScheduler"),mf=i(" or "),Zi=s("code"),gf=i("ScoreSdeVpScheduler"),_f=i("."),dc=l(),Re=s("h2"),mt=s("a"),ea=s("span"),f(Kr.$$.fragment),vf=l(),ta=s("span"),bf=i("Designing Re-usable schedulers"),lc=l(),hn=s("p"),Sf=i(`The core design principle between the schedule functions is to be model, system, and framework independent.
This allows for rapid experimentation and cleaner abstractions in the code, where the model prediction is separated from the sample update.
To this end, the design of schedulers is such that:`),cc=l(),gt=s("ul"),ra=s("li"),Df=i("Schedulers can be used interchangeably between diffusion models in inference to find the preferred trade-off between speed and generation quality."),xf=l(),sa=s("li"),$f=i("Schedulers are currently by default in PyTorch, but are designed to be framework independent (partial Jax support currently exists)."),uc=l(),Qe=s("h2"),_t=s("a"),oa=s("span"),f(Rr.$$.fragment),Ef=l(),na=s("span"),yf=i("API"),pc=l(),mn=s("p"),wf=i("The core API for any new scheduler must follow a limited structure."),fc=l(),Ce=s("ul"),Qr=s("li"),Mf=i("Schedulers should provide one or more "),ia=s("code"),Pf=i("def step(...)"),Tf=i(" functions that should be called to update the generated sample iteratively."),Cf=l(),jr=s("li"),kf=i("Schedulers should provide a "),aa=s("code"),Of=i("set_timesteps(...)"),Af=i(" method that configures the parameters of a schedule function for a specific inference task."),Vf=l(),da=s("li"),Ff=i("Schedulers should be framework-specific."),hc=l(),vt=s("p"),If=i("The base class "),gn=s("a"),Nf=i("SchedulerMixin"),Lf=i(" implements low level utilities used by multiple schedulers."),mc=l(),je=s("h3"),bt=s("a"),la=s("span"),f(Wr.$$.fragment),qf=l(),ca=s("span"),Kf=i("SchedulerMixin"),gc=l(),We=s("div"),f(Ur.$$.fragment),Rf=l(),ua=s("p"),Qf=i("Mixin containing common functions for the schedulers."),_c=l(),Ue=s("h3"),St=s("a"),pa=s("span"),f(Br.$$.fragment),jf=l(),fa=s("span"),Wf=i("SchedulerOutput"),vc=i("\n\nThe class `SchedulerOutput` contains the outputs from any schedulers `step(...)` call.\n"),Be=s("div"),f(Hr.$$.fragment),Uf=l(),ha=s("p"),Bf=i("Base class for the scheduler\u2019s step function output."),bc=l(),He=s("h3"),Dt=s("a"),ma=s("span"),f(Gr.$$.fragment),Hf=l(),ga=s("span"),Gf=i("Implemented Schedulers"),Sc=l(),Ge=s("h4"),xt=s("a"),_a=s("span"),f(zr.$$.fragment),zf=l(),va=s("span"),Yf=i("Denoising diffusion implicit models (DDIM)"),Dc=l(),_n=s("p"),Jf=i("Original paper can be found here."),xc=l(),P=s("div"),f(Yr.$$.fragment),Xf=l(),ba=s("p"),Zf=i(`Denoising diffusion implicit models is a scheduler that extends the denoising procedure introduced in denoising
diffusion probabilistic models (DDPMs) with non-Markovian guidance.`),eh=l(),A=s("p"),vn=s("a"),th=i("~ConfigMixin"),rh=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),Sa=s("code"),sh=i("__init__"),oh=i(`
function, such as `),Da=s("code"),nh=i("num_train_timesteps"),ih=i(". They can be accessed via "),xa=s("code"),ah=i("scheduler.config.num_train_timesteps"),dh=i(`.
`),bn=s("a"),lh=i("~ConfigMixin"),ch=i(" also provides general loading and saving functionality via the "),Sn=s("a"),uh=i("save_config()"),ph=i(` and
`),Dn=s("a"),fh=i("from_config()"),hh=i(" functions."),mh=l(),xn=s("p"),gh=i("For more details, see the original paper: "),Jr=s("a"),_h=i("https://arxiv.org/abs/2010.02502"),vh=l(),$t=s("div"),f(Xr.$$.fragment),bh=l(),$a=s("p"),Sh=i(`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),Dh=l(),Et=s("div"),f(Zr.$$.fragment),xh=l(),Ea=s("p"),$h=i("Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference."),Eh=l(),yt=s("div"),f(es.$$.fragment),yh=l(),ya=s("p"),wh=i(`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),$c=l(),ze=s("h4"),wt=s("a"),wa=s("span"),f(ts.$$.fragment),Mh=l(),Ma=s("span"),Ph=i("Denoising diffusion probabilistic models (DDPM)"),Ec=l(),Mt=s("p"),Th=i("Original paper can be found "),rs=s("a"),Ch=i("here"),kh=i("."),yc=l(),T=s("div"),f(ss.$$.fragment),Oh=l(),Pa=s("p"),Ah=i(`Denoising diffusion probabilistic models (DDPMs) explores the connections between denoising score matching and
Langevin dynamics sampling.`),Vh=l(),V=s("p"),$n=s("a"),Fh=i("~ConfigMixin"),Ih=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),Ta=s("code"),Nh=i("__init__"),Lh=i(`
function, such as `),Ca=s("code"),qh=i("num_train_timesteps"),Kh=i(". They can be accessed via "),ka=s("code"),Rh=i("scheduler.config.num_train_timesteps"),Qh=i(`.
`),En=s("a"),jh=i("~ConfigMixin"),Wh=i(" also provides general loading and saving functionality via the "),yn=s("a"),Uh=i("save_config()"),Bh=i(` and
`),wn=s("a"),Hh=i("from_config()"),Gh=i(" functions."),zh=l(),Mn=s("p"),Yh=i("For more details, see the original paper: "),os=s("a"),Jh=i("https://arxiv.org/abs/2006.11239"),Xh=l(),Pt=s("div"),f(ns.$$.fragment),Zh=l(),Oa=s("p"),em=i(`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),tm=l(),Tt=s("div"),f(is.$$.fragment),rm=l(),Aa=s("p"),sm=i("Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference."),om=l(),Ct=s("div"),f(as.$$.fragment),nm=l(),Va=s("p"),im=i(`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),wc=l(),Ye=s("h4"),kt=s("a"),Fa=s("span"),f(ds.$$.fragment),am=l(),Ia=s("span"),dm=i("Multistep DPM-Solver"),Mc=l(),xe=s("p"),lm=i("Original paper can be found "),ls=s("a"),cm=i("here"),um=i(" and the "),cs=s("a"),pm=i("improved version"),fm=i(". The original implementation can be found "),us=s("a"),hm=i("here"),mm=i("."),Pc=l(),S=s("div"),f(ps.$$.fragment),gm=l(),Na=s("p"),_m=i(`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.`),vm=l(),Ot=s("p"),bm=i("For more details, see the original paper: "),fs=s("a"),Sm=i("https://arxiv.org/abs/2206.00927"),Dm=i(" and "),hs=s("a"),xm=i("https://arxiv.org/abs/2211.01095"),$m=l(),Je=s("p"),Em=i(`Currently, we support the multistep DPM-Solver for both noise prediction models and data prediction models. We
recommend to use `),La=s("code"),ym=i("solver_order=2"),wm=i(" for guided sampling, and "),qa=s("code"),Mm=i("solver_order=3"),Pm=i(" for unconditional sampling."),Tm=l(),Me=s("p"),Cm=i("We also support the \u201Cdynamic thresholding\u201D method in Imagen ("),ms=s("a"),km=i("https://arxiv.org/abs/2205.11487"),Om=i(`). For pixel-space
diffusion models, you can set both `),Ka=s("code"),Am=i('algorithm_type="dpmsolver++"'),Vm=i(" and "),Ra=s("code"),Fm=i("thresholding=True"),Im=i(` to use the dynamic
thresholding. Note that the thresholding method is unsuitable for latent-space diffusion models (such as
stable-diffusion).`),Nm=l(),F=s("p"),Pn=s("a"),Lm=i("~ConfigMixin"),qm=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),Qa=s("code"),Km=i("__init__"),Rm=i(`
function, such as `),ja=s("code"),Qm=i("num_train_timesteps"),jm=i(". They can be accessed via "),Wa=s("code"),Wm=i("scheduler.config.num_train_timesteps"),Um=i(`.
`),Tn=s("a"),Bm=i("~ConfigMixin"),Hm=i(" also provides general loading and saving functionality via the "),Cn=s("a"),Gm=i("save_config()"),zm=i(` and
`),kn=s("a"),Ym=i("from_config()"),Jm=i(" functions."),Xm=l(),$e=s("div"),f(gs.$$.fragment),Zm=l(),Ua=s("p"),eg=i("Convert the model output to the corresponding type that the algorithm (DPM-Solver / DPM-Solver++) needs."),tg=l(),Ba=s("p"),rg=i(`DPM-Solver is designed to discretize an integral of the noise prediciton 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.`),sg=l(),Ha=s("p"),og=i(`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.`),ng=l(),ke=s("div"),f(_s.$$.fragment),ig=l(),Ga=s("p"),ag=i("One step for the first-order DPM-Solver (equivalent to DDIM)."),dg=l(),vs=s("p"),lg=i("See "),bs=s("a"),cg=i("https://arxiv.org/abs/2206.00927"),ug=i(" for the detailed derivation."),pg=l(),At=s("div"),f(Ss.$$.fragment),fg=l(),za=s("p"),hg=i("One step for the second-order multistep DPM-Solver."),mg=l(),Vt=s("div"),f(Ds.$$.fragment),gg=l(),Ya=s("p"),_g=i("One step for the third-order multistep DPM-Solver."),vg=l(),Ft=s("div"),f(xs.$$.fragment),bg=l(),Ja=s("p"),Sg=i(`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),Dg=l(),It=s("div"),f($s.$$.fragment),xg=l(),Xa=s("p"),$g=i("Sets the timesteps used for the diffusion chain. Supporting function to be run before inference."),Eg=l(),Nt=s("div"),f(Es.$$.fragment),yg=l(),Za=s("p"),wg=i("Step function propagating the sample with the multistep DPM-Solver."),Tc=l(),Xe=s("h4"),Lt=s("a"),ed=s("span"),f(ys.$$.fragment),Mg=l(),td=s("span"),Pg=i("Variance exploding, stochastic sampling from Karras et. al"),Cc=l(),qt=s("p"),Tg=i("Original paper can be found "),ws=s("a"),Cg=i("here"),kg=i("."),kc=l(),x=s("div"),f(Ms.$$.fragment),Og=l(),rd=s("p"),Ag=i(`Stochastic sampling from Karras et al. [1] tailored to the Variance-Expanding (VE) models [2]. Use Algorithm 2 and
the VE column of Table 1 from [1] for reference.`),Vg=l(),Kt=s("p"),Fg=i(`[1] Karras, Tero, et al. \u201CElucidating the Design Space of Diffusion-Based Generative Models.\u201D
`),Ps=s("a"),Ig=i("https://arxiv.org/abs/2206.00364"),Ng=i(` [2] Song, Yang, et al. \u201CScore-based generative modeling through stochastic
differential equations.\u201D `),Ts=s("a"),Lg=i("https://arxiv.org/abs/2011.13456"),qg=l(),I=s("p"),On=s("a"),Kg=i("~ConfigMixin"),Rg=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),sd=s("code"),Qg=i("__init__"),jg=i(`
function, such as `),od=s("code"),Wg=i("num_train_timesteps"),Ug=i(". They can be accessed via "),nd=s("code"),Bg=i("scheduler.config.num_train_timesteps"),Hg=i(`.
`),An=s("a"),Gg=i("~ConfigMixin"),zg=i(" also provides general loading and saving functionality via the "),Vn=s("a"),Yg=i("save_config()"),Jg=i(` and
`),Fn=s("a"),Xg=i("from_config()"),Zg=i(" functions."),e_=l(),Cs=s("p"),t_=i(`For more details on the parameters, see the original paper\u2019s Appendix E.: \u201CElucidating the Design Space of
Diffusion-Based Generative Models.\u201D `),ks=s("a"),r_=i("https://arxiv.org/abs/2206.00364"),s_=i(`. The grid search values used to find the
optimal {s_noise, s_churn, s_min, s_max} for a specific model are described in Table 5 of the paper.`),o_=l(),Oe=s("div"),f(Os.$$.fragment),n_=l(),id=s("p"),i_=i(`Explicit Langevin-like \u201Cchurn\u201D step of adding noise to the sample according to a factor gamma_i \u2265 0 to reach a
higher noise level sigma_hat = sigma_i + gamma_i*sigma_i.`),a_=l(),ad=s("p"),d_=i("TODO Args:"),l_=l(),Rt=s("div"),f(As.$$.fragment),c_=l(),dd=s("p"),u_=i(`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),p_=l(),Qt=s("div"),f(Vs.$$.fragment),f_=l(),ld=s("p"),h_=i("Sets the continuous timesteps used for the diffusion chain. Supporting function to be run before inference."),m_=l(),jt=s("div"),f(Fs.$$.fragment),g_=l(),cd=s("p"),__=i(`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),v_=l(),Wt=s("div"),f(Is.$$.fragment),b_=l(),ud=s("p"),S_=i("Correct the predicted sample based on the output model_output of the network. TODO complete description"),Oc=l(),Ze=s("h4"),Ut=s("a"),pd=s("span"),f(Ns.$$.fragment),D_=l(),fd=s("span"),x_=i("Linear multistep scheduler for discrete beta schedules"),Ac=l(),Bt=s("p"),$_=i("Original implementation can be found "),Ls=s("a"),E_=i("here"),y_=i("."),Vc=l(),C=s("div"),f(qs.$$.fragment),w_=l(),In=s("p"),M_=i(`Linear Multistep Scheduler for discrete beta schedules. Based on the original k-diffusion implementation by
Katherine Crowson:
`),Ks=s("a"),P_=i("https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L181"),T_=l(),N=s("p"),Nn=s("a"),C_=i("~ConfigMixin"),k_=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),hd=s("code"),O_=i("__init__"),A_=i(`
function, such as `),md=s("code"),V_=i("num_train_timesteps"),F_=i(". They can be accessed via "),gd=s("code"),I_=i("scheduler.config.num_train_timesteps"),N_=i(`.
`),Ln=s("a"),L_=i("~ConfigMixin"),q_=i(" also provides general loading and saving functionality via the "),qn=s("a"),K_=i("save_config()"),R_=i(` and
`),Kn=s("a"),Q_=i("from_config()"),j_=i(" functions."),W_=l(),Ht=s("div"),f(Rs.$$.fragment),U_=l(),_d=s("p"),B_=i("Compute a linear multistep coefficient."),H_=l(),Gt=s("div"),f(Qs.$$.fragment),G_=l(),js=s("p"),z_=i("Scales the denoising model input by "),vd=s("code"),Y_=i("(sigma**2 + 1) ** 0.5"),J_=i(" to match the K-LMS algorithm."),X_=l(),zt=s("div"),f(Ws.$$.fragment),Z_=l(),bd=s("p"),ev=i("Sets the timesteps used for the diffusion chain. Supporting function to be run before inference."),tv=l(),Yt=s("div"),f(Us.$$.fragment),rv=l(),Sd=s("p"),sv=i(`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),Fc=l(),et=s("h4"),Jt=s("a"),Dd=s("span"),f(Bs.$$.fragment),ov=l(),xd=s("span"),nv=i("Pseudo numerical methods for diffusion models (PNDM)"),Ic=l(),Xt=s("p"),iv=i("Original implementation can be found "),Hs=s("a"),av=i("here"),dv=i("."),Nc=l(),$=s("div"),f(Gs.$$.fragment),lv=l(),$d=s("p"),cv=i(`Pseudo numerical methods for diffusion models (PNDM) proposes using more advanced ODE integration techniques,
namely Runge-Kutta method and a linear multi-step method.`),uv=l(),L=s("p"),Rn=s("a"),pv=i("~ConfigMixin"),fv=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),Ed=s("code"),hv=i("__init__"),mv=i(`
function, such as `),yd=s("code"),gv=i("num_train_timesteps"),_v=i(". They can be accessed via "),wd=s("code"),vv=i("scheduler.config.num_train_timesteps"),bv=i(`.
`),Qn=s("a"),Sv=i("~ConfigMixin"),Dv=i(" also provides general loading and saving functionality via the "),jn=s("a"),xv=i("save_config()"),$v=i(` and
`),Wn=s("a"),Ev=i("from_config()"),yv=i(" functions."),wv=l(),Un=s("p"),Mv=i("For more details, see the original paper: "),zs=s("a"),Pv=i("https://arxiv.org/abs/2202.09778"),Tv=l(),Zt=s("div"),f(Ys.$$.fragment),Cv=l(),Md=s("p"),kv=i(`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),Ov=l(),er=s("div"),f(Js.$$.fragment),Av=l(),Pd=s("p"),Vv=i("Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference."),Fv=l(),Ae=s("div"),f(Xs.$$.fragment),Iv=l(),Td=s("p"),Nv=i(`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),Lv=l(),Pe=s("p"),qv=i("This function calls "),Cd=s("code"),Kv=i("step_prk()"),Rv=i(" or "),kd=s("code"),Qv=i("step_plms()"),jv=i(" depending on the internal variable "),Od=s("code"),Wv=i("counter"),Uv=i("."),Bv=l(),tr=s("div"),f(Zs.$$.fragment),Hv=l(),Ad=s("p"),Gv=i(`Step function propagating the sample with the linear multi-step method. This has one forward pass with multiple
times to approximate the solution.`),zv=l(),rr=s("div"),f(eo.$$.fragment),Yv=l(),Vd=s("p"),Jv=i(`Step function propagating the sample with the Runge-Kutta method. RK takes 4 forward passes to approximate the
solution to the differential equation.`),Lc=l(),tt=s("h4"),sr=s("a"),Fd=s("span"),f(to.$$.fragment),Xv=l(),Id=s("span"),Zv=i("variance exploding stochastic differential equation (VE-SDE) scheduler"),qc=l(),or=s("p"),e1=i("Original paper can be found "),ro=s("a"),t1=i("here"),r1=i("."),Kc=l(),E=s("div"),f(so.$$.fragment),s1=l(),Nd=s("p"),o1=i("The variance exploding stochastic differential equation (SDE) scheduler."),n1=l(),Bn=s("p"),i1=i("For more information, see the original paper: "),oo=s("a"),a1=i("https://arxiv.org/abs/2011.13456"),d1=l(),q=s("p"),Hn=s("a"),l1=i("~ConfigMixin"),c1=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),Ld=s("code"),u1=i("__init__"),p1=i(`
function, such as `),qd=s("code"),f1=i("num_train_timesteps"),h1=i(". They can be accessed via "),Kd=s("code"),m1=i("scheduler.config.num_train_timesteps"),g1=i(`.
`),Gn=s("a"),_1=i("~ConfigMixin"),v1=i(" also provides general loading and saving functionality via the "),zn=s("a"),b1=i("save_config()"),S1=i(` and
`),Yn=s("a"),D1=i("from_config()"),x1=i(" functions."),$1=l(),nr=s("div"),f(no.$$.fragment),E1=l(),Rd=s("p"),y1=i(`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),w1=l(),Ve=s("div"),f(io.$$.fragment),M1=l(),Qd=s("p"),P1=i("Sets the noise scales used for the diffusion chain. Supporting function to be run before inference."),T1=l(),rt=s("p"),C1=i("The sigmas control the weight of the "),jd=s("code"),k1=i("drift"),O1=i(" and "),Wd=s("code"),A1=i("diffusion"),V1=i(" components of sample update."),F1=l(),ir=s("div"),f(ao.$$.fragment),I1=l(),Ud=s("p"),N1=i("Sets the continuous timesteps used for the diffusion chain. Supporting function to be run before inference."),L1=l(),ar=s("div"),f(lo.$$.fragment),q1=l(),Bd=s("p"),K1=i(`Correct the predicted sample based on the output model_output of the network. This is often run repeatedly
after making the prediction for the previous timestep.`),R1=l(),dr=s("div"),f(co.$$.fragment),Q1=l(),Hd=s("p"),j1=i(`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),Rc=l(),st=s("h4"),lr=s("a"),Gd=s("span"),f(uo.$$.fragment),W1=l(),zd=s("span"),U1=i("improved pseudo numerical methods for diffusion models (iPNDM)"),Qc=l(),cr=s("p"),B1=i("Original implementation can be found "),po=s("a"),H1=i("here"),G1=i("."),jc=l(),k=s("div"),f(fo.$$.fragment),z1=l(),Jn=s("p"),Y1=i(`Improved Pseudo numerical methods for diffusion models (iPNDM) ported from @crowsonkb\u2019s amazing k-diffusion
`),ho=s("a"),J1=i("library"),X1=l(),K=s("p"),Xn=s("a"),Z1=i("~ConfigMixin"),eb=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),Yd=s("code"),tb=i("__init__"),rb=i(`
function, such as `),Jd=s("code"),sb=i("num_train_timesteps"),ob=i(". They can be accessed via "),Xd=s("code"),nb=i("scheduler.config.num_train_timesteps"),ib=i(`.
`),Zn=s("a"),ab=i("~ConfigMixin"),db=i(" also provides general loading and saving functionality via the "),ei=s("a"),lb=i("save_config()"),cb=i(` and
`),ti=s("a"),ub=i("from_config()"),pb=i(" functions."),fb=l(),ri=s("p"),hb=i("For more details, see the original paper: "),mo=s("a"),mb=i("https://arxiv.org/abs/2202.09778"),gb=l(),ur=s("div"),f(go.$$.fragment),_b=l(),Zd=s("p"),vb=i(`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),bb=l(),pr=s("div"),f(_o.$$.fragment),Sb=l(),el=s("p"),Db=i("Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference."),xb=l(),fr=s("div"),f(vo.$$.fragment),$b=l(),tl=s("p"),Eb=i(`Step function propagating the sample with the linear multi-step method. This has one forward pass with multiple
times to approximate the solution.`),Wc=l(),ot=s("h4"),hr=s("a"),rl=s("span"),f(bo.$$.fragment),yb=l(),sl=s("span"),wb=i("variance preserving stochastic differential equation (VP-SDE) scheduler"),Uc=l(),mr=s("p"),Mb=i("Original paper can be found "),So=s("a"),Pb=i("here"),Tb=i("."),Bc=l(),f(gr.$$.fragment),Hc=l(),te=s("div"),f(Do.$$.fragment),Cb=l(),ol=s("p"),kb=i("The variance preserving stochastic differential equation (SDE) scheduler."),Ob=l(),R=s("p"),si=s("a"),Ab=i("~ConfigMixin"),Vb=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),nl=s("code"),Fb=i("__init__"),Ib=i(`
function, such as `),il=s("code"),Nb=i("num_train_timesteps"),Lb=i(". They can be accessed via "),al=s("code"),qb=i("scheduler.config.num_train_timesteps"),Kb=i(`.
`),oi=s("a"),Rb=i("~ConfigMixin"),Qb=i(" also provides general loading and saving functionality via the "),ni=s("a"),jb=i("save_config()"),Wb=i(` and
`),ii=s("a"),Ub=i("from_config()"),Bb=i(" functions."),Hb=l(),ai=s("p"),Gb=i("For more information, see the original paper: "),xo=s("a"),zb=i("https://arxiv.org/abs/2011.13456"),Yb=l(),dl=s("p"),Jb=i("UNDER CONSTRUCTION"),Gc=l(),nt=s("h4"),_r=s("a"),ll=s("span"),f($o.$$.fragment),Xb=l(),cl=s("span"),Zb=i("Euler scheduler"),zc=l(),Fe=s("p"),e0=i("Euler scheduler (Algorithm 2) from the paper "),Eo=s("a"),t0=i("Elucidating the Design Space of Diffusion-Based Generative Models"),r0=i(" by Karras et al. (2022). Based on the original "),yo=s("a"),s0=i("k-diffusion"),o0=i(` implementation by Katherine Crowson.
Fast scheduler which often times generates good outputs with 20-30 steps.`),Yc=l(),Y=s("div"),f(wo.$$.fragment),n0=l(),vr=s("p"),i0=i("Euler scheduler (Algorithm 2) from Karras et al. (2022) "),Mo=s("a"),a0=i("https://arxiv.org/abs/2206.00364"),d0=i(`. . Based on the original
k-diffusion implementation by Katherine Crowson:
`),Po=s("a"),l0=i("https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L51"),c0=l(),Q=s("p"),di=s("a"),u0=i("~ConfigMixin"),p0=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),ul=s("code"),f0=i("__init__"),h0=i(`
function, such as `),pl=s("code"),m0=i("num_train_timesteps"),g0=i(". They can be accessed via "),fl=s("code"),_0=i("scheduler.config.num_train_timesteps"),v0=i(`.
`),li=s("a"),b0=i("~ConfigMixin"),S0=i(" also provides general loading and saving functionality via the "),ci=s("a"),D0=i("save_config()"),x0=i(` and
`),ui=s("a"),$0=i("from_config()"),E0=i(" functions."),y0=l(),br=s("div"),f(To.$$.fragment),w0=l(),Co=s("p"),M0=i("Scales the denoising model input by "),hl=s("code"),P0=i("(sigma**2 + 1) ** 0.5"),T0=i(" to match the Euler algorithm."),C0=l(),Sr=s("div"),f(ko.$$.fragment),k0=l(),ml=s("p"),O0=i("Sets the timesteps used for the diffusion chain. Supporting function to be run before inference."),A0=l(),Dr=s("div"),f(Oo.$$.fragment),V0=l(),gl=s("p"),F0=i(`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),Jc=l(),it=s("h4"),xr=s("a"),_l=s("span"),f(Ao.$$.fragment),I0=l(),vl=s("span"),N0=i("Euler Ancestral scheduler"),Xc=l(),pi=s("p"),L0=i(`Ancestral sampling with Euler method steps. Based on the original (k-diffusion)[https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L72] implementation by Katherine Crowson.
Fast scheduler which often times generates good outputs with 20-30 steps.`),Zc=l(),J=s("div"),f(Vo.$$.fragment),q0=l(),fi=s("p"),K0=i(`Ancestral sampling with Euler method steps. Based on the original k-diffusion implementation by Katherine Crowson:
`),Fo=s("a"),R0=i("https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L72"),Q0=l(),j=s("p"),hi=s("a"),j0=i("~ConfigMixin"),W0=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),bl=s("code"),U0=i("__init__"),B0=i(`
function, such as `),Sl=s("code"),H0=i("num_train_timesteps"),G0=i(". They can be accessed via "),Dl=s("code"),z0=i("scheduler.config.num_train_timesteps"),Y0=i(`.
`),mi=s("a"),J0=i("~ConfigMixin"),X0=i(" also provides general loading and saving functionality via the "),gi=s("a"),Z0=i("save_config()"),e2=i(` and
`),_i=s("a"),t2=i("from_config()"),r2=i(" functions."),s2=l(),$r=s("div"),f(Io.$$.fragment),o2=l(),No=s("p"),n2=i("Scales the denoising model input by "),xl=s("code"),i2=i("(sigma**2 + 1) ** 0.5"),a2=i(" to match the Euler algorithm."),d2=l(),Er=s("div"),f(Lo.$$.fragment),l2=l(),$l=s("p"),c2=i("Sets the timesteps used for the diffusion chain. Supporting function to be run before inference."),u2=l(),yr=s("div"),f(qo.$$.fragment),p2=l(),El=s("p"),f2=i(`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),eu=l(),at=s("h4"),wr=s("a"),yl=s("span"),f(Ko.$$.fragment),h2=l(),wl=s("span"),m2=i("VQDiffusionScheduler"),tu=l(),Ro=s("p"),g2=i("Original paper can be found "),Qo=s("a"),_2=i("here"),ru=l(),y=s("div"),f(jo.$$.fragment),v2=l(),Ml=s("p"),b2=i("The VQ-diffusion transformer outputs predicted probabilities of the initial unnoised image."),S2=l(),Pl=s("p"),D2=i(`The VQ-diffusion scheduler converts the transformer\u2019s output into a sample for the unnoised image at the previous
diffusion timestep.`),x2=l(),W=s("p"),vi=s("a"),$2=i("~ConfigMixin"),E2=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),Tl=s("code"),y2=i("__init__"),w2=i(`
function, such as `),Cl=s("code"),M2=i("num_train_timesteps"),P2=i(". They can be accessed via "),kl=s("code"),T2=i("scheduler.config.num_train_timesteps"),C2=i(`.
`),bi=s("a"),k2=i("~ConfigMixin"),O2=i(" also provides general loading and saving functionality via the "),Si=s("a"),A2=i("save_config()"),V2=i(` and
`),Di=s("a"),F2=i("from_config()"),I2=i(" functions."),N2=l(),xi=s("p"),L2=i("For more details, see the original paper: "),Wo=s("a"),q2=i("https://arxiv.org/abs/2111.14822"),K2=l(),Ie=s("div"),f(Uo.$$.fragment),R2=l(),Bo=s("p"),Q2=i(`Returns the log probabilities of the rows from the (cumulative or non-cumulative) transition matrix for each
latent pixel in `),Ol=s("code"),j2=i("x_t"),W2=i("."),U2=l(),Al=s("p"),B2=i(`See equation (7) for the complete non-cumulative transition matrix. The complete cumulative transition matrix
is the same structure except the parameters (alpha, beta, gamma) are the cumulative analogs.`),H2=l(),U=s("div"),f(Ho.$$.fragment),G2=l(),Go=s("p"),z2=i("Calculates the log probabilities for the predicted classes of the image at timestep "),Vl=s("code"),Y2=i("t-1"),J2=i(". I.e. Equation (11)."),X2=l(),Fl=s("p"),Z2=i(`Instead of directly computing equation (11), we use Equation (5) to restate Equation (11) in terms of only
forward probabilities.`),e4=l(),Il=s("p"),t4=i("Equation (11) stated in terms of forward probabilities via Equation (5):"),r4=l(),Nl=s("p"),s4=i("Where:"),o4=l(),Ll=s("ul"),zo=s("li"),n4=i("the sum is over x"),ql=s("em"),i4=i("0 = {C_0 \u2026 C"),a4=i("{k-1}} (classes for x_0)"),d4=l(),dt=s("p"),l4=i("p(x"),Kl=s("em"),c4=i("{t-1} | x_t) = sum( q(x_t | x"),u4=i("{t-1}) "),Rl=s("em"),p4=i("q(x_{t-1} | x_0)"),f4=i(" p(x_0) / q(x_t | x_0) )"),h4=l(),Mr=s("div"),f(Yo.$$.fragment),m4=l(),Ql=s("p"),g4=i("Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference."),_4=l(),Pr=s("div"),f(Jo.$$.fragment),v4=l(),Xo=s("p"),b4=i(`Predict the sample at the previous timestep via the reverse transition distribution i.e. Equation (11). See the
docstring for `),jl=s("code"),S4=i("self.q_posterior"),D4=i(" for more in depth docs on how Equation (11) is computed."),su=l(),lt=s("h4"),Tr=s("a"),Wl=s("span"),f(Zo.$$.fragment),x4=l(),Ul=s("span"),$4=i("RePaint scheduler"),ou=l(),Te=s("p"),E4=i(`DDPM-based inpainting scheduler for unsupervised inpainting with extreme masks.
Intended for use with `),$i=s("a"),y4=i("RePaintPipeline"),w4=i(`.
Based on the paper `),en=s("a"),M4=i("RePaint: Inpainting using Denoising Diffusion Probabilistic Models"),P4=i(`
and the original implementation by Andreas Lugmayr et al.: `),tn=s("a"),T4=i("https://github.com/andreas128/RePaint"),nu=l(),X=s("div"),f(rn.$$.fragment),C4=l(),Bl=s("p"),k4=i("RePaint is a schedule for DDPM inpainting inside a given mask."),O4=l(),B=s("p"),Ei=s("a"),A4=i("~ConfigMixin"),V4=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),Hl=s("code"),F4=i("__init__"),I4=i(`
function, such as `),Gl=s("code"),N4=i("num_train_timesteps"),L4=i(". They can be accessed via "),zl=s("code"),q4=i("scheduler.config.num_train_timesteps"),K4=i(`.
`),yi=s("a"),R4=i("~ConfigMixin"),Q4=i(" also provides general loading and saving functionality via the "),wi=s("a"),j4=i("save_config()"),W4=i(` and
`),Mi=s("a"),U4=i("from_config()"),B4=i(" functions."),H4=l(),Pi=s("p"),G4=i("For more details, see the original paper: "),sn=s("a"),z4=i("https://arxiv.org/pdf/2201.09865.pdf"),Y4=l(),Cr=s("div"),f(on.$$.fragment),J4=l(),Yl=s("p"),X4=i(`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),Z4=l(),kr=s("div"),f(nn.$$.fragment),eS=l(),Jl=s("p"),tS=i(`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),this.h()},l(r){const u=K5('[data-svelte="svelte-1phssyn"]',document.head);Z=o(u,"META",{name:!0,content:!0}),u.forEach(t),ct=c(r),ee=o(r,"H1",{class:!0});var an=n(ee);De=o(an,"A",{id:!0,class:!0,href:!0});var mS=n(De);Ki=o(mS,"SPAN",{});var gS=n(Ki);h(Ir.$$.fragment,gS),gS.forEach(t),mS.forEach(t),Lp=c(an),Ri=o(an,"SPAN",{});var _S=n(Ri);qp=a(_S,"Schedulers"),_S.forEach(t),an.forEach(t),rc=c(r),ln=o(r,"P",{});var vS=n(ln);Kp=a(vS,"Diffusers contains multiple pre-built schedule functions for the diffusion process."),vS.forEach(t),sc=c(r),Le=o(r,"H2",{class:!0});var au=n(Le);ut=o(au,"A",{id:!0,class:!0,href:!0});var bS=n(ut);Qi=o(bS,"SPAN",{});var SS=n(Qi);h(Nr.$$.fragment,SS),SS.forEach(t),bS.forEach(t),Rp=c(au),ji=o(au,"SPAN",{});var DS=n(ji);Qp=a(DS,"What is a scheduler?"),DS.forEach(t),au.forEach(t),oc=c(r),pt=o(r,"P",{});var du=n(pt);jp=a(du,"The schedule functions, denoted "),Wi=o(du,"EM",{});var xS=n(Wi);Wp=a(xS,"Schedulers"),xS.forEach(t),Up=a(du," in the library take in the output of a trained model, a sample which the diffusion process is iterating on, and a timestep to return a denoised sample."),du.forEach(t),nc=c(r),ft=o(r,"UL",{});var lu=n(ft);cn=o(lu,"LI",{});var rS=n(cn);Bp=a(rS,"Schedulers define the methodology for iteratively adding noise to an image or for updating a sample based on model outputs."),Lr=o(rS,"UL",{});var cu=n(Lr);Ui=o(cu,"LI",{});var $S=n(Ui);Hp=a($S,"adding noise in different manners represent the algorithmic processes to train a diffusion model by adding noise to images."),$S.forEach(t),Gp=c(cu),Bi=o(cu,"LI",{});var ES=n(Bi);zp=a(ES,"for inference, the scheduler defines how to update a sample based on an output from a pretrained model."),ES.forEach(t),cu.forEach(t),rS.forEach(t),Yp=c(lu),qe=o(lu,"LI",{});var Ti=n(qe);Jp=a(Ti,"Schedulers are often defined by a "),Hi=o(Ti,"EM",{});var yS=n(Hi);Xp=a(yS,"noise schedule"),yS.forEach(t),Zp=a(Ti," and an "),Gi=o(Ti,"EM",{});var wS=n(Gi);ef=a(wS,"update rule"),wS.forEach(t),tf=a(Ti," to solve the differential equation solution."),Ti.forEach(t),lu.forEach(t),ic=c(r),Ke=o(r,"H3",{class:!0});var uu=n(Ke);ht=o(uu,"A",{id:!0,class:!0,href:!0});var MS=n(ht);zi=o(MS,"SPAN",{});var PS=n(zi);h(qr.$$.fragment,PS),PS.forEach(t),MS.forEach(t),rf=c(uu),Yi=o(uu,"SPAN",{});var TS=n(Yi);sf=a(TS,"Discrete versus continuous schedulers"),TS.forEach(t),uu.forEach(t),ac=c(r),O=o(r,"P",{});var me=n(O);of=a(me,`All schedulers take in a timestep to predict the updated version of the sample being diffused.
The timesteps dictate where in the diffusion process the step is, where data is generated by iterating forward in time and inference is executed by propagating backwards through timesteps.
Different algorithms use timesteps that both discrete (accepting `),Ji=o(me,"CODE",{});var CS=n(Ji);nf=a(CS,"int"),CS.forEach(t),af=a(me," inputs), such as the "),un=o(me,"A",{href:!0});var kS=n(un);df=a(kS,"DDPMScheduler"),kS.forEach(t),lf=a(me," or "),pn=o(me,"A",{href:!0});var OS=n(pn);cf=a(OS,"PNDMScheduler"),OS.forEach(t),uf=a(me,", and continuous (accepting "),Xi=o(me,"CODE",{});var AS=n(Xi);pf=a(AS,"float"),AS.forEach(t),ff=a(me," inputs), such as the score-based schedulers "),fn=o(me,"A",{href:!0});var VS=n(fn);hf=a(VS,"ScoreSdeVeScheduler"),VS.forEach(t),mf=a(me," or "),Zi=o(me,"CODE",{});var FS=n(Zi);gf=a(FS,"ScoreSdeVpScheduler"),FS.forEach(t),_f=a(me,"."),me.forEach(t),dc=c(r),Re=o(r,"H2",{class:!0});var pu=n(Re);mt=o(pu,"A",{id:!0,class:!0,href:!0});var IS=n(mt);ea=o(IS,"SPAN",{});var NS=n(ea);h(Kr.$$.fragment,NS),NS.forEach(t),IS.forEach(t),vf=c(pu),ta=o(pu,"SPAN",{});var LS=n(ta);bf=a(LS,"Designing Re-usable schedulers"),LS.forEach(t),pu.forEach(t),lc=c(r),hn=o(r,"P",{});var qS=n(hn);Sf=a(qS,`The core design principle between the schedule functions is to be model, system, and framework independent.
This allows for rapid experimentation and cleaner abstractions in the code, where the model prediction is separated from the sample update.
To this end, the design of schedulers is such that:`),qS.forEach(t),cc=c(r),gt=o(r,"UL",{});var fu=n(gt);ra=o(fu,"LI",{});var KS=n(ra);Df=a(KS,"Schedulers can be used interchangeably between diffusion models in inference to find the preferred trade-off between speed and generation quality."),KS.forEach(t),xf=c(fu),sa=o(fu,"LI",{});var RS=n(sa);$f=a(RS,"Schedulers are currently by default in PyTorch, but are designed to be framework independent (partial Jax support currently exists)."),RS.forEach(t),fu.forEach(t),uc=c(r),Qe=o(r,"H2",{class:!0});var hu=n(Qe);_t=o(hu,"A",{id:!0,class:!0,href:!0});var QS=n(_t);oa=o(QS,"SPAN",{});var jS=n(oa);h(Rr.$$.fragment,jS),jS.forEach(t),QS.forEach(t),Ef=c(hu),na=o(hu,"SPAN",{});var WS=n(na);yf=a(WS,"API"),WS.forEach(t),hu.forEach(t),pc=c(r),mn=o(r,"P",{});var US=n(mn);wf=a(US,"The core API for any new scheduler must follow a limited structure."),US.forEach(t),fc=c(r),Ce=o(r,"UL",{});var Ci=n(Ce);Qr=o(Ci,"LI",{});var mu=n(Qr);Mf=a(mu,"Schedulers should provide one or more "),ia=o(mu,"CODE",{});var BS=n(ia);Pf=a(BS,"def step(...)"),BS.forEach(t),Tf=a(mu," functions that should be called to update the generated sample iteratively."),mu.forEach(t),Cf=c(Ci),jr=o(Ci,"LI",{});var gu=n(jr);kf=a(gu,"Schedulers should provide a "),aa=o(gu,"CODE",{});var HS=n(aa);Of=a(HS,"set_timesteps(...)"),HS.forEach(t),Af=a(gu," method that configures the parameters of a schedule function for a specific inference task."),gu.forEach(t),Vf=c(Ci),da=o(Ci,"LI",{});var GS=n(da);Ff=a(GS,"Schedulers should be framework-specific."),GS.forEach(t),Ci.forEach(t),hc=c(r),vt=o(r,"P",{});var _u=n(vt);If=a(_u,"The base class "),gn=o(_u,"A",{href:!0});var zS=n(gn);Nf=a(zS,"SchedulerMixin"),zS.forEach(t),Lf=a(_u," implements low level utilities used by multiple schedulers."),_u.forEach(t),mc=c(r),je=o(r,"H3",{class:!0});var vu=n(je);bt=o(vu,"A",{id:!0,class:!0,href:!0});var YS=n(bt);la=o(YS,"SPAN",{});var JS=n(la);h(Wr.$$.fragment,JS),JS.forEach(t),YS.forEach(t),qf=c(vu),ca=o(vu,"SPAN",{});var XS=n(ca);Kf=a(XS,"SchedulerMixin"),XS.forEach(t),vu.forEach(t),gc=c(r),We=o(r,"DIV",{class:!0});var bu=n(We);h(Ur.$$.fragment,bu),Rf=c(bu),ua=o(bu,"P",{});var ZS=n(ua);Qf=a(ZS,"Mixin containing common functions for the schedulers."),ZS.forEach(t),bu.forEach(t),_c=c(r),Ue=o(r,"H3",{class:!0});var Su=n(Ue);St=o(Su,"A",{id:!0,class:!0,href:!0});var eD=n(St);pa=o(eD,"SPAN",{});var tD=n(pa);h(Br.$$.fragment,tD),tD.forEach(t),eD.forEach(t),jf=c(Su),fa=o(Su,"SPAN",{});var rD=n(fa);Wf=a(rD,"SchedulerOutput"),rD.forEach(t),Su.forEach(t),vc=a(r,"\n\nThe class `SchedulerOutput` contains the outputs from any schedulers `step(...)` call.\n"),Be=o(r,"DIV",{class:!0});var Du=n(Be);h(Hr.$$.fragment,Du),Uf=c(Du),ha=o(Du,"P",{});var sD=n(ha);Bf=a(sD,"Base class for the scheduler\u2019s step function output."),sD.forEach(t),Du.forEach(t),bc=c(r),He=o(r,"H3",{class:!0});var xu=n(He);Dt=o(xu,"A",{id:!0,class:!0,href:!0});var oD=n(Dt);ma=o(oD,"SPAN",{});var nD=n(ma);h(Gr.$$.fragment,nD),nD.forEach(t),oD.forEach(t),Hf=c(xu),ga=o(xu,"SPAN",{});var iD=n(ga);Gf=a(iD,"Implemented Schedulers"),iD.forEach(t),xu.forEach(t),Sc=c(r),Ge=o(r,"H4",{class:!0});var $u=n(Ge);xt=o($u,"A",{id:!0,class:!0,href:!0});var aD=n(xt);_a=o(aD,"SPAN",{});var dD=n(_a);h(zr.$$.fragment,dD),dD.forEach(t),aD.forEach(t),zf=c($u),va=o($u,"SPAN",{});var lD=n(va);Yf=a(lD,"Denoising diffusion implicit models (DDIM)"),lD.forEach(t),$u.forEach(t),Dc=c(r),_n=o(r,"P",{});var cD=n(_n);Jf=a(cD,"Original paper can be found here."),cD.forEach(t),xc=c(r),P=o(r,"DIV",{class:!0});var ge=n(P);h(Yr.$$.fragment,ge),Xf=c(ge),ba=o(ge,"P",{});var uD=n(ba);Zf=a(uD,`Denoising diffusion implicit models is a scheduler that extends the denoising procedure introduced in denoising
diffusion probabilistic models (DDPMs) with non-Markovian guidance.`),uD.forEach(t),eh=c(ge),A=o(ge,"P",{});var re=n(A);vn=o(re,"A",{href:!0});var pD=n(vn);th=a(pD,"~ConfigMixin"),pD.forEach(t),rh=a(re," takes care of storing all config attributes that are passed in the scheduler\u2019s "),Sa=o(re,"CODE",{});var fD=n(Sa);sh=a(fD,"__init__"),fD.forEach(t),oh=a(re,`
function, such as `),Da=o(re,"CODE",{});var hD=n(Da);nh=a(hD,"num_train_timesteps"),hD.forEach(t),ih=a(re,". They can be accessed via "),xa=o(re,"CODE",{});var mD=n(xa);ah=a(mD,"scheduler.config.num_train_timesteps"),mD.forEach(t),dh=a(re,`.
`),bn=o(re,"A",{href:!0});var gD=n(bn);lh=a(gD,"~ConfigMixin"),gD.forEach(t),ch=a(re," also provides general loading and saving functionality via the "),Sn=o(re,"A",{href:!0});var _D=n(Sn);uh=a(_D,"save_config()"),_D.forEach(t),ph=a(re,` and
`),Dn=o(re,"A",{href:!0});var vD=n(Dn);fh=a(vD,"from_config()"),vD.forEach(t),hh=a(re," functions."),re.forEach(t),mh=c(ge),xn=o(ge,"P",{});var sS=n(xn);gh=a(sS,"For more details, see the original paper: "),Jr=o(sS,"A",{href:!0,rel:!0});var bD=n(Jr);_h=a(bD,"https://arxiv.org/abs/2010.02502"),bD.forEach(t),sS.forEach(t),vh=c(ge),$t=o(ge,"DIV",{class:!0});var Eu=n($t);h(Xr.$$.fragment,Eu),bh=c(Eu),$a=o(Eu,"P",{});var SD=n($a);Sh=a(SD,`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),SD.forEach(t),Eu.forEach(t),Dh=c(ge),Et=o(ge,"DIV",{class:!0});var yu=n(Et);h(Zr.$$.fragment,yu),xh=c(yu),Ea=o(yu,"P",{});var DD=n(Ea);$h=a(DD,"Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference."),DD.forEach(t),yu.forEach(t),Eh=c(ge),yt=o(ge,"DIV",{class:!0});var wu=n(yt);h(es.$$.fragment,wu),yh=c(wu),ya=o(wu,"P",{});var xD=n(ya);wh=a(xD,`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),xD.forEach(t),wu.forEach(t),ge.forEach(t),$c=c(r),ze=o(r,"H4",{class:!0});var Mu=n(ze);wt=o(Mu,"A",{id:!0,class:!0,href:!0});var $D=n(wt);wa=o($D,"SPAN",{});var ED=n(wa);h(ts.$$.fragment,ED),ED.forEach(t),$D.forEach(t),Mh=c(Mu),Ma=o(Mu,"SPAN",{});var yD=n(Ma);Ph=a(yD,"Denoising diffusion probabilistic models (DDPM)"),yD.forEach(t),Mu.forEach(t),Ec=c(r),Mt=o(r,"P",{});var Pu=n(Mt);Th=a(Pu,"Original paper can be found "),rs=o(Pu,"A",{href:!0,rel:!0});var wD=n(rs);Ch=a(wD,"here"),wD.forEach(t),kh=a(Pu,"."),Pu.forEach(t),yc=c(r),T=o(r,"DIV",{class:!0});var _e=n(T);h(ss.$$.fragment,_e),Oh=c(_e),Pa=o(_e,"P",{});var MD=n(Pa);Ah=a(MD,`Denoising diffusion probabilistic models (DDPMs) explores the connections between denoising score matching and
Langevin dynamics sampling.`),MD.forEach(t),Vh=c(_e),V=o(_e,"P",{});var se=n(V);$n=o(se,"A",{href:!0});var PD=n($n);Fh=a(PD,"~ConfigMixin"),PD.forEach(t),Ih=a(se," takes care of storing all config attributes that are passed in the scheduler\u2019s "),Ta=o(se,"CODE",{});var TD=n(Ta);Nh=a(TD,"__init__"),TD.forEach(t),Lh=a(se,`
function, such as `),Ca=o(se,"CODE",{});var CD=n(Ca);qh=a(CD,"num_train_timesteps"),CD.forEach(t),Kh=a(se,". They can be accessed via "),ka=o(se,"CODE",{});var kD=n(ka);Rh=a(kD,"scheduler.config.num_train_timesteps"),kD.forEach(t),Qh=a(se,`.
`),En=o(se,"A",{href:!0});var OD=n(En);jh=a(OD,"~ConfigMixin"),OD.forEach(t),Wh=a(se," also provides general loading and saving functionality via the "),yn=o(se,"A",{href:!0});var AD=n(yn);Uh=a(AD,"save_config()"),AD.forEach(t),Bh=a(se,` and
`),wn=o(se,"A",{href:!0});var VD=n(wn);Hh=a(VD,"from_config()"),VD.forEach(t),Gh=a(se," functions."),se.forEach(t),zh=c(_e),Mn=o(_e,"P",{});var oS=n(Mn);Yh=a(oS,"For more details, see the original paper: "),os=o(oS,"A",{href:!0,rel:!0});var FD=n(os);Jh=a(FD,"https://arxiv.org/abs/2006.11239"),FD.forEach(t),oS.forEach(t),Xh=c(_e),Pt=o(_e,"DIV",{class:!0});var Tu=n(Pt);h(ns.$$.fragment,Tu),Zh=c(Tu),Oa=o(Tu,"P",{});var ID=n(Oa);em=a(ID,`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),ID.forEach(t),Tu.forEach(t),tm=c(_e),Tt=o(_e,"DIV",{class:!0});var Cu=n(Tt);h(is.$$.fragment,Cu),rm=c(Cu),Aa=o(Cu,"P",{});var ND=n(Aa);sm=a(ND,"Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference."),ND.forEach(t),Cu.forEach(t),om=c(_e),Ct=o(_e,"DIV",{class:!0});var ku=n(Ct);h(as.$$.fragment,ku),nm=c(ku),Va=o(ku,"P",{});var LD=n(Va);im=a(LD,`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),LD.forEach(t),ku.forEach(t),_e.forEach(t),wc=c(r),Ye=o(r,"H4",{class:!0});var Ou=n(Ye);kt=o(Ou,"A",{id:!0,class:!0,href:!0});var qD=n(kt);Fa=o(qD,"SPAN",{});var KD=n(Fa);h(ds.$$.fragment,KD),KD.forEach(t),qD.forEach(t),am=c(Ou),Ia=o(Ou,"SPAN",{});var RD=n(Ia);dm=a(RD,"Multistep DPM-Solver"),RD.forEach(t),Ou.forEach(t),Mc=c(r),xe=o(r,"P",{});var Or=n(xe);lm=a(Or,"Original paper can be found "),ls=o(Or,"A",{href:!0,rel:!0});var QD=n(ls);cm=a(QD,"here"),QD.forEach(t),um=a(Or," and the "),cs=o(Or,"A",{href:!0,rel:!0});var jD=n(cs);pm=a(jD,"improved version"),jD.forEach(t),fm=a(Or,". The original implementation can be found "),us=o(Or,"A",{href:!0,rel:!0});var WD=n(us);hm=a(WD,"here"),WD.forEach(t),mm=a(Or,"."),Or.forEach(t),Pc=c(r),S=o(r,"DIV",{class:!0});var D=n(S);h(ps.$$.fragment,D),gm=c(D),Na=o(D,"P",{});var UD=n(Na);_m=a(UD,`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.`),UD.forEach(t),vm=c(D),Ot=o(D,"P",{});var Xl=n(Ot);bm=a(Xl,"For more details, see the original paper: "),fs=o(Xl,"A",{href:!0,rel:!0});var BD=n(fs);Sm=a(BD,"https://arxiv.org/abs/2206.00927"),BD.forEach(t),Dm=a(Xl," and "),hs=o(Xl,"A",{href:!0,rel:!0});var HD=n(hs);xm=a(HD,"https://arxiv.org/abs/2211.01095"),HD.forEach(t),Xl.forEach(t),$m=c(D),Je=o(D,"P",{});var ki=n(Je);Em=a(ki,`Currently, we support the multistep DPM-Solver for both noise prediction models and data prediction models. We
recommend to use `),La=o(ki,"CODE",{});var GD=n(La);ym=a(GD,"solver_order=2"),GD.forEach(t),wm=a(ki," for guided sampling, and "),qa=o(ki,"CODE",{});var zD=n(qa);Mm=a(zD,"solver_order=3"),zD.forEach(t),Pm=a(ki," for unconditional sampling."),ki.forEach(t),Tm=c(D),Me=o(D,"P",{});var Ar=n(Me);Cm=a(Ar,"We also support the \u201Cdynamic thresholding\u201D method in Imagen ("),ms=o(Ar,"A",{href:!0,rel:!0});var YD=n(ms);km=a(YD,"https://arxiv.org/abs/2205.11487"),YD.forEach(t),Om=a(Ar,`). For pixel-space
diffusion models, you can set both `),Ka=o(Ar,"CODE",{});var JD=n(Ka);Am=a(JD,'algorithm_type="dpmsolver++"'),JD.forEach(t),Vm=a(Ar," and "),Ra=o(Ar,"CODE",{});var XD=n(Ra);Fm=a(XD,"thresholding=True"),XD.forEach(t),Im=a(Ar,` to use the dynamic
thresholding. Note that the thresholding method is unsuitable for latent-space diffusion models (such as
stable-diffusion).`),Ar.forEach(t),Nm=c(D),F=o(D,"P",{});var oe=n(F);Pn=o(oe,"A",{href:!0});var ZD=n(Pn);Lm=a(ZD,"~ConfigMixin"),ZD.forEach(t),qm=a(oe," takes care of storing all config attributes that are passed in the scheduler\u2019s "),Qa=o(oe,"CODE",{});var ex=n(Qa);Km=a(ex,"__init__"),ex.forEach(t),Rm=a(oe,`
function, such as `),ja=o(oe,"CODE",{});var tx=n(ja);Qm=a(tx,"num_train_timesteps"),tx.forEach(t),jm=a(oe,". They can be accessed via "),Wa=o(oe,"CODE",{});var rx=n(Wa);Wm=a(rx,"scheduler.config.num_train_timesteps"),rx.forEach(t),Um=a(oe,`.
`),Tn=o(oe,"A",{href:!0});var sx=n(Tn);Bm=a(sx,"~ConfigMixin"),sx.forEach(t),Hm=a(oe," also provides general loading and saving functionality via the "),Cn=o(oe,"A",{href:!0});var ox=n(Cn);Gm=a(ox,"save_config()"),ox.forEach(t),zm=a(oe,` and
`),kn=o(oe,"A",{href:!0});var nx=n(kn);Ym=a(nx,"from_config()"),nx.forEach(t),Jm=a(oe," functions."),oe.forEach(t),Xm=c(D),$e=o(D,"DIV",{class:!0});var Vr=n($e);h(gs.$$.fragment,Vr),Zm=c(Vr),Ua=o(Vr,"P",{});var ix=n(Ua);eg=a(ix,"Convert the model output to the corresponding type that the algorithm (DPM-Solver / DPM-Solver++) needs."),ix.forEach(t),tg=c(Vr),Ba=o(Vr,"P",{});var ax=n(Ba);rg=a(ax,`DPM-Solver is designed to discretize an integral of the noise prediciton 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.`),ax.forEach(t),sg=c(Vr),Ha=o(Vr,"P",{});var dx=n(Ha);og=a(dx,`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.`),dx.forEach(t),Vr.forEach(t),ng=c(D),ke=o(D,"DIV",{class:!0});var Oi=n(ke);h(_s.$$.fragment,Oi),ig=c(Oi),Ga=o(Oi,"P",{});var lx=n(Ga);ag=a(lx,"One step for the first-order DPM-Solver (equivalent to DDIM)."),lx.forEach(t),dg=c(Oi),vs=o(Oi,"P",{});var Au=n(vs);lg=a(Au,"See "),bs=o(Au,"A",{href:!0,rel:!0});var cx=n(bs);cg=a(cx,"https://arxiv.org/abs/2206.00927"),cx.forEach(t),ug=a(Au," for the detailed derivation."),Au.forEach(t),Oi.forEach(t),pg=c(D),At=o(D,"DIV",{class:!0});var Vu=n(At);h(Ss.$$.fragment,Vu),fg=c(Vu),za=o(Vu,"P",{});var ux=n(za);hg=a(ux,"One step for the second-order multistep DPM-Solver."),ux.forEach(t),Vu.forEach(t),mg=c(D),Vt=o(D,"DIV",{class:!0});var Fu=n(Vt);h(Ds.$$.fragment,Fu),gg=c(Fu),Ya=o(Fu,"P",{});var px=n(Ya);_g=a(px,"One step for the third-order multistep DPM-Solver."),px.forEach(t),Fu.forEach(t),vg=c(D),Ft=o(D,"DIV",{class:!0});var Iu=n(Ft);h(xs.$$.fragment,Iu),bg=c(Iu),Ja=o(Iu,"P",{});var fx=n(Ja);Sg=a(fx,`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),fx.forEach(t),Iu.forEach(t),Dg=c(D),It=o(D,"DIV",{class:!0});var Nu=n(It);h($s.$$.fragment,Nu),xg=c(Nu),Xa=o(Nu,"P",{});var hx=n(Xa);$g=a(hx,"Sets the timesteps used for the diffusion chain. Supporting function to be run before inference."),hx.forEach(t),Nu.forEach(t),Eg=c(D),Nt=o(D,"DIV",{class:!0});var Lu=n(Nt);h(Es.$$.fragment,Lu),yg=c(Lu),Za=o(Lu,"P",{});var mx=n(Za);wg=a(mx,"Step function propagating the sample with the multistep DPM-Solver."),mx.forEach(t),Lu.forEach(t),D.forEach(t),Tc=c(r),Xe=o(r,"H4",{class:!0});var qu=n(Xe);Lt=o(qu,"A",{id:!0,class:!0,href:!0});var gx=n(Lt);ed=o(gx,"SPAN",{});var _x=n(ed);h(ys.$$.fragment,_x),_x.forEach(t),gx.forEach(t),Mg=c(qu),td=o(qu,"SPAN",{});var vx=n(td);Pg=a(vx,"Variance exploding, stochastic sampling from Karras et. al"),vx.forEach(t),qu.forEach(t),Cc=c(r),qt=o(r,"P",{});var Ku=n(qt);Tg=a(Ku,"Original paper can be found "),ws=o(Ku,"A",{href:!0,rel:!0});var bx=n(ws);Cg=a(bx,"here"),bx.forEach(t),kg=a(Ku,"."),Ku.forEach(t),kc=c(r),x=o(r,"DIV",{class:!0});var M=n(x);h(Ms.$$.fragment,M),Og=c(M),rd=o(M,"P",{});var Sx=n(rd);Ag=a(Sx,`Stochastic sampling from Karras et al. [1] tailored to the Variance-Expanding (VE) models [2]. Use Algorithm 2 and
the VE column of Table 1 from [1] for reference.`),Sx.forEach(t),Vg=c(M),Kt=o(M,"P",{});var Zl=n(Kt);Fg=a(Zl,`[1] Karras, Tero, et al. \u201CElucidating the Design Space of Diffusion-Based Generative Models.\u201D
`),Ps=o(Zl,"A",{href:!0,rel:!0});var Dx=n(Ps);Ig=a(Dx,"https://arxiv.org/abs/2206.00364"),Dx.forEach(t),Ng=a(Zl,` [2] Song, Yang, et al. \u201CScore-based generative modeling through stochastic
differential equations.\u201D `),Ts=o(Zl,"A",{href:!0,rel:!0});var xx=n(Ts);Lg=a(xx,"https://arxiv.org/abs/2011.13456"),xx.forEach(t),Zl.forEach(t),qg=c(M),I=o(M,"P",{});var ne=n(I);On=o(ne,"A",{href:!0});var $x=n(On);Kg=a($x,"~ConfigMixin"),$x.forEach(t),Rg=a(ne," takes care of storing all config attributes that are passed in the scheduler\u2019s "),sd=o(ne,"CODE",{});var Ex=n(sd);Qg=a(Ex,"__init__"),Ex.forEach(t),jg=a(ne,`
function, such as `),od=o(ne,"CODE",{});var yx=n(od);Wg=a(yx,"num_train_timesteps"),yx.forEach(t),Ug=a(ne,". They can be accessed via "),nd=o(ne,"CODE",{});var wx=n(nd);Bg=a(wx,"scheduler.config.num_train_timesteps"),wx.forEach(t),Hg=a(ne,`.
`),An=o(ne,"A",{href:!0});var Mx=n(An);Gg=a(Mx,"~ConfigMixin"),Mx.forEach(t),zg=a(ne," also provides general loading and saving functionality via the "),Vn=o(ne,"A",{href:!0});var Px=n(Vn);Yg=a(Px,"save_config()"),Px.forEach(t),Jg=a(ne,` and
`),Fn=o(ne,"A",{href:!0});var Tx=n(Fn);Xg=a(Tx,"from_config()"),Tx.forEach(t),Zg=a(ne," functions."),ne.forEach(t),e_=c(M),Cs=o(M,"P",{});var Ru=n(Cs);t_=a(Ru,`For more details on the parameters, see the original paper\u2019s Appendix E.: \u201CElucidating the Design Space of
Diffusion-Based Generative Models.\u201D `),ks=o(Ru,"A",{href:!0,rel:!0});var Cx=n(ks);r_=a(Cx,"https://arxiv.org/abs/2206.00364"),Cx.forEach(t),s_=a(Ru,`. The grid search values used to find the
optimal {s_noise, s_churn, s_min, s_max} for a specific model are described in Table 5 of the paper.`),Ru.forEach(t),o_=c(M),Oe=o(M,"DIV",{class:!0});var Ai=n(Oe);h(Os.$$.fragment,Ai),n_=c(Ai),id=o(Ai,"P",{});var kx=n(id);i_=a(kx,`Explicit Langevin-like \u201Cchurn\u201D step of adding noise to the sample according to a factor gamma_i \u2265 0 to reach a
higher noise level sigma_hat = sigma_i + gamma_i*sigma_i.`),kx.forEach(t),a_=c(Ai),ad=o(Ai,"P",{});var Ox=n(ad);d_=a(Ox,"TODO Args:"),Ox.forEach(t),Ai.forEach(t),l_=c(M),Rt=o(M,"DIV",{class:!0});var Qu=n(Rt);h(As.$$.fragment,Qu),c_=c(Qu),dd=o(Qu,"P",{});var Ax=n(dd);u_=a(Ax,`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),Ax.forEach(t),Qu.forEach(t),p_=c(M),Qt=o(M,"DIV",{class:!0});var ju=n(Qt);h(Vs.$$.fragment,ju),f_=c(ju),ld=o(ju,"P",{});var Vx=n(ld);h_=a(Vx,"Sets the continuous timesteps used for the diffusion chain. Supporting function to be run before inference."),Vx.forEach(t),ju.forEach(t),m_=c(M),jt=o(M,"DIV",{class:!0});var Wu=n(jt);h(Fs.$$.fragment,Wu),g_=c(Wu),cd=o(Wu,"P",{});var Fx=n(cd);__=a(Fx,`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),Fx.forEach(t),Wu.forEach(t),v_=c(M),Wt=o(M,"DIV",{class:!0});var Uu=n(Wt);h(Is.$$.fragment,Uu),b_=c(Uu),ud=o(Uu,"P",{});var Ix=n(ud);S_=a(Ix,"Correct the predicted sample based on the output model_output of the network. TODO complete description"),Ix.forEach(t),Uu.forEach(t),M.forEach(t),Oc=c(r),Ze=o(r,"H4",{class:!0});var Bu=n(Ze);Ut=o(Bu,"A",{id:!0,class:!0,href:!0});var Nx=n(Ut);pd=o(Nx,"SPAN",{});var Lx=n(pd);h(Ns.$$.fragment,Lx),Lx.forEach(t),Nx.forEach(t),D_=c(Bu),fd=o(Bu,"SPAN",{});var qx=n(fd);x_=a(qx,"Linear multistep scheduler for discrete beta schedules"),qx.forEach(t),Bu.forEach(t),Ac=c(r),Bt=o(r,"P",{});var Hu=n(Bt);$_=a(Hu,"Original implementation can be found "),Ls=o(Hu,"A",{href:!0,rel:!0});var Kx=n(Ls);E_=a(Kx,"here"),Kx.forEach(t),y_=a(Hu,"."),Hu.forEach(t),Vc=c(r),C=o(r,"DIV",{class:!0});var ve=n(C);h(qs.$$.fragment,ve),w_=c(ve),In=o(ve,"P",{});var nS=n(In);M_=a(nS,`Linear Multistep Scheduler for discrete beta schedules. Based on the original k-diffusion implementation by
Katherine Crowson:
`),Ks=o(nS,"A",{href:!0,rel:!0});var Rx=n(Ks);P_=a(Rx,"https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L181"),Rx.forEach(t),nS.forEach(t),T_=c(ve),N=o(ve,"P",{});var ie=n(N);Nn=o(ie,"A",{href:!0});var Qx=n(Nn);C_=a(Qx,"~ConfigMixin"),Qx.forEach(t),k_=a(ie," takes care of storing all config attributes that are passed in the scheduler\u2019s "),hd=o(ie,"CODE",{});var jx=n(hd);O_=a(jx,"__init__"),jx.forEach(t),A_=a(ie,`
function, such as `),md=o(ie,"CODE",{});var Wx=n(md);V_=a(Wx,"num_train_timesteps"),Wx.forEach(t),F_=a(ie,". They can be accessed via "),gd=o(ie,"CODE",{});var Ux=n(gd);I_=a(Ux,"scheduler.config.num_train_timesteps"),Ux.forEach(t),N_=a(ie,`.
`),Ln=o(ie,"A",{href:!0});var Bx=n(Ln);L_=a(Bx,"~ConfigMixin"),Bx.forEach(t),q_=a(ie," also provides general loading and saving functionality via the "),qn=o(ie,"A",{href:!0});var Hx=n(qn);K_=a(Hx,"save_config()"),Hx.forEach(t),R_=a(ie,` and
`),Kn=o(ie,"A",{href:!0});var Gx=n(Kn);Q_=a(Gx,"from_config()"),Gx.forEach(t),j_=a(ie," functions."),ie.forEach(t),W_=c(ve),Ht=o(ve,"DIV",{class:!0});var Gu=n(Ht);h(Rs.$$.fragment,Gu),U_=c(Gu),_d=o(Gu,"P",{});var zx=n(_d);B_=a(zx,"Compute a linear multistep coefficient."),zx.forEach(t),Gu.forEach(t),H_=c(ve),Gt=o(ve,"DIV",{class:!0});var zu=n(Gt);h(Qs.$$.fragment,zu),G_=c(zu),js=o(zu,"P",{});var Yu=n(js);z_=a(Yu,"Scales the denoising model input by "),vd=o(Yu,"CODE",{});var Yx=n(vd);Y_=a(Yx,"(sigma**2 + 1) ** 0.5"),Yx.forEach(t),J_=a(Yu," to match the K-LMS algorithm."),Yu.forEach(t),zu.forEach(t),X_=c(ve),zt=o(ve,"DIV",{class:!0});var Ju=n(zt);h(Ws.$$.fragment,Ju),Z_=c(Ju),bd=o(Ju,"P",{});var Jx=n(bd);ev=a(Jx,"Sets the timesteps used for the diffusion chain. Supporting function to be run before inference."),Jx.forEach(t),Ju.forEach(t),tv=c(ve),Yt=o(ve,"DIV",{class:!0});var Xu=n(Yt);h(Us.$$.fragment,Xu),rv=c(Xu),Sd=o(Xu,"P",{});var Xx=n(Sd);sv=a(Xx,`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),Xx.forEach(t),Xu.forEach(t),ve.forEach(t),Fc=c(r),et=o(r,"H4",{class:!0});var Zu=n(et);Jt=o(Zu,"A",{id:!0,class:!0,href:!0});var Zx=n(Jt);Dd=o(Zx,"SPAN",{});var e$=n(Dd);h(Bs.$$.fragment,e$),e$.forEach(t),Zx.forEach(t),ov=c(Zu),xd=o(Zu,"SPAN",{});var t$=n(xd);nv=a(t$,"Pseudo numerical methods for diffusion models (PNDM)"),t$.forEach(t),Zu.forEach(t),Ic=c(r),Xt=o(r,"P",{});var ep=n(Xt);iv=a(ep,"Original implementation can be found "),Hs=o(ep,"A",{href:!0,rel:!0});var r$=n(Hs);av=a(r$,"here"),r$.forEach(t),dv=a(ep,"."),ep.forEach(t),Nc=c(r),$=o(r,"DIV",{class:!0});var H=n($);h(Gs.$$.fragment,H),lv=c(H),$d=o(H,"P",{});var s$=n($d);cv=a(s$,`Pseudo numerical methods for diffusion models (PNDM) proposes using more advanced ODE integration techniques,
namely Runge-Kutta method and a linear multi-step method.`),s$.forEach(t),uv=c(H),L=o(H,"P",{});var ae=n(L);Rn=o(ae,"A",{href:!0});var o$=n(Rn);pv=a(o$,"~ConfigMixin"),o$.forEach(t),fv=a(ae," takes care of storing all config attributes that are passed in the scheduler\u2019s "),Ed=o(ae,"CODE",{});var n$=n(Ed);hv=a(n$,"__init__"),n$.forEach(t),mv=a(ae,`
function, such as `),yd=o(ae,"CODE",{});var i$=n(yd);gv=a(i$,"num_train_timesteps"),i$.forEach(t),_v=a(ae,". They can be accessed via "),wd=o(ae,"CODE",{});var a$=n(wd);vv=a(a$,"scheduler.config.num_train_timesteps"),a$.forEach(t),bv=a(ae,`.
`),Qn=o(ae,"A",{href:!0});var d$=n(Qn);Sv=a(d$,"~ConfigMixin"),d$.forEach(t),Dv=a(ae," also provides general loading and saving functionality via the "),jn=o(ae,"A",{href:!0});var l$=n(jn);xv=a(l$,"save_config()"),l$.forEach(t),$v=a(ae,` and
`),Wn=o(ae,"A",{href:!0});var c$=n(Wn);Ev=a(c$,"from_config()"),c$.forEach(t),yv=a(ae," functions."),ae.forEach(t),wv=c(H),Un=o(H,"P",{});var iS=n(Un);Mv=a(iS,"For more details, see the original paper: "),zs=o(iS,"A",{href:!0,rel:!0});var u$=n(zs);Pv=a(u$,"https://arxiv.org/abs/2202.09778"),u$.forEach(t),iS.forEach(t),Tv=c(H),Zt=o(H,"DIV",{class:!0});var tp=n(Zt);h(Ys.$$.fragment,tp),Cv=c(tp),Md=o(tp,"P",{});var p$=n(Md);kv=a(p$,`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),p$.forEach(t),tp.forEach(t),Ov=c(H),er=o(H,"DIV",{class:!0});var rp=n(er);h(Js.$$.fragment,rp),Av=c(rp),Pd=o(rp,"P",{});var f$=n(Pd);Vv=a(f$,"Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference."),f$.forEach(t),rp.forEach(t),Fv=c(H),Ae=o(H,"DIV",{class:!0});var Vi=n(Ae);h(Xs.$$.fragment,Vi),Iv=c(Vi),Td=o(Vi,"P",{});var h$=n(Td);Nv=a(h$,`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),h$.forEach(t),Lv=c(Vi),Pe=o(Vi,"P",{});var Fr=n(Pe);qv=a(Fr,"This function calls "),Cd=o(Fr,"CODE",{});var m$=n(Cd);Kv=a(m$,"step_prk()"),m$.forEach(t),Rv=a(Fr," or "),kd=o(Fr,"CODE",{});var g$=n(kd);Qv=a(g$,"step_plms()"),g$.forEach(t),jv=a(Fr," depending on the internal variable "),Od=o(Fr,"CODE",{});var _$=n(Od);Wv=a(_$,"counter"),_$.forEach(t),Uv=a(Fr,"."),Fr.forEach(t),Vi.forEach(t),Bv=c(H),tr=o(H,"DIV",{class:!0});var sp=n(tr);h(Zs.$$.fragment,sp),Hv=c(sp),Ad=o(sp,"P",{});var v$=n(Ad);Gv=a(v$,`Step function propagating the sample with the linear multi-step method. This has one forward pass with multiple
times to approximate the solution.`),v$.forEach(t),sp.forEach(t),zv=c(H),rr=o(H,"DIV",{class:!0});var op=n(rr);h(eo.$$.fragment,op),Yv=c(op),Vd=o(op,"P",{});var b$=n(Vd);Jv=a(b$,`Step function propagating the sample with the Runge-Kutta method. RK takes 4 forward passes to approximate the
solution to the differential equation.`),b$.forEach(t),op.forEach(t),H.forEach(t),Lc=c(r),tt=o(r,"H4",{class:!0});var np=n(tt);sr=o(np,"A",{id:!0,class:!0,href:!0});var S$=n(sr);Fd=o(S$,"SPAN",{});var D$=n(Fd);h(to.$$.fragment,D$),D$.forEach(t),S$.forEach(t),Xv=c(np),Id=o(np,"SPAN",{});var x$=n(Id);Zv=a(x$,"variance exploding stochastic differential equation (VE-SDE) scheduler"),x$.forEach(t),np.forEach(t),qc=c(r),or=o(r,"P",{});var ip=n(or);e1=a(ip,"Original paper can be found "),ro=o(ip,"A",{href:!0,rel:!0});var $$=n(ro);t1=a($$,"here"),$$.forEach(t),r1=a(ip,"."),ip.forEach(t),Kc=c(r),E=o(r,"DIV",{class:!0});var G=n(E);h(so.$$.fragment,G),s1=c(G),Nd=o(G,"P",{});var E$=n(Nd);o1=a(E$,"The variance exploding stochastic differential equation (SDE) scheduler."),E$.forEach(t),n1=c(G),Bn=o(G,"P",{});var aS=n(Bn);i1=a(aS,"For more information, see the original paper: "),oo=o(aS,"A",{href:!0,rel:!0});var y$=n(oo);a1=a(y$,"https://arxiv.org/abs/2011.13456"),y$.forEach(t),aS.forEach(t),d1=c(G),q=o(G,"P",{});var de=n(q);Hn=o(de,"A",{href:!0});var w$=n(Hn);l1=a(w$,"~ConfigMixin"),w$.forEach(t),c1=a(de," takes care of storing all config attributes that are passed in the scheduler\u2019s "),Ld=o(de,"CODE",{});var M$=n(Ld);u1=a(M$,"__init__"),M$.forEach(t),p1=a(de,`
function, such as `),qd=o(de,"CODE",{});var P$=n(qd);f1=a(P$,"num_train_timesteps"),P$.forEach(t),h1=a(de,". They can be accessed via "),Kd=o(de,"CODE",{});var T$=n(Kd);m1=a(T$,"scheduler.config.num_train_timesteps"),T$.forEach(t),g1=a(de,`.
`),Gn=o(de,"A",{href:!0});var C$=n(Gn);_1=a(C$,"~ConfigMixin"),C$.forEach(t),v1=a(de," also provides general loading and saving functionality via the "),zn=o(de,"A",{href:!0});var k$=n(zn);b1=a(k$,"save_config()"),k$.forEach(t),S1=a(de,` and
`),Yn=o(de,"A",{href:!0});var O$=n(Yn);D1=a(O$,"from_config()"),O$.forEach(t),x1=a(de," functions."),de.forEach(t),$1=c(G),nr=o(G,"DIV",{class:!0});var ap=n(nr);h(no.$$.fragment,ap),E1=c(ap),Rd=o(ap,"P",{});var A$=n(Rd);y1=a(A$,`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),A$.forEach(t),ap.forEach(t),w1=c(G),Ve=o(G,"DIV",{class:!0});var Fi=n(Ve);h(io.$$.fragment,Fi),M1=c(Fi),Qd=o(Fi,"P",{});var V$=n(Qd);P1=a(V$,"Sets the noise scales used for the diffusion chain. Supporting function to be run before inference."),V$.forEach(t),T1=c(Fi),rt=o(Fi,"P",{});var Ii=n(rt);C1=a(Ii,"The sigmas control the weight of the "),jd=o(Ii,"CODE",{});var F$=n(jd);k1=a(F$,"drift"),F$.forEach(t),O1=a(Ii," and "),Wd=o(Ii,"CODE",{});var I$=n(Wd);A1=a(I$,"diffusion"),I$.forEach(t),V1=a(Ii," components of sample update."),Ii.forEach(t),Fi.forEach(t),F1=c(G),ir=o(G,"DIV",{class:!0});var dp=n(ir);h(ao.$$.fragment,dp),I1=c(dp),Ud=o(dp,"P",{});var N$=n(Ud);N1=a(N$,"Sets the continuous timesteps used for the diffusion chain. Supporting function to be run before inference."),N$.forEach(t),dp.forEach(t),L1=c(G),ar=o(G,"DIV",{class:!0});var lp=n(ar);h(lo.$$.fragment,lp),q1=c(lp),Bd=o(lp,"P",{});var L$=n(Bd);K1=a(L$,`Correct the predicted sample based on the output model_output of the network. This is often run repeatedly
after making the prediction for the previous timestep.`),L$.forEach(t),lp.forEach(t),R1=c(G),dr=o(G,"DIV",{class:!0});var cp=n(dr);h(co.$$.fragment,cp),Q1=c(cp),Hd=o(cp,"P",{});var q$=n(Hd);j1=a(q$,`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),q$.forEach(t),cp.forEach(t),G.forEach(t),Rc=c(r),st=o(r,"H4",{class:!0});var up=n(st);lr=o(up,"A",{id:!0,class:!0,href:!0});var K$=n(lr);Gd=o(K$,"SPAN",{});var R$=n(Gd);h(uo.$$.fragment,R$),R$.forEach(t),K$.forEach(t),W1=c(up),zd=o(up,"SPAN",{});var Q$=n(zd);U1=a(Q$,"improved pseudo numerical methods for diffusion models (iPNDM)"),Q$.forEach(t),up.forEach(t),Qc=c(r),cr=o(r,"P",{});var pp=n(cr);B1=a(pp,"Original implementation can be found "),po=o(pp,"A",{href:!0,rel:!0});var j$=n(po);H1=a(j$,"here"),j$.forEach(t),G1=a(pp,"."),pp.forEach(t),jc=c(r),k=o(r,"DIV",{class:!0});var be=n(k);h(fo.$$.fragment,be),z1=c(be),Jn=o(be,"P",{});var dS=n(Jn);Y1=a(dS,`Improved Pseudo numerical methods for diffusion models (iPNDM) ported from @crowsonkb\u2019s amazing k-diffusion
`),ho=o(dS,"A",{href:!0,rel:!0});var W$=n(ho);J1=a(W$,"library"),W$.forEach(t),dS.forEach(t),X1=c(be),K=o(be,"P",{});var le=n(K);Xn=o(le,"A",{href:!0});var U$=n(Xn);Z1=a(U$,"~ConfigMixin"),U$.forEach(t),eb=a(le," takes care of storing all config attributes that are passed in the scheduler\u2019s "),Yd=o(le,"CODE",{});var B$=n(Yd);tb=a(B$,"__init__"),B$.forEach(t),rb=a(le,`
function, such as `),Jd=o(le,"CODE",{});var H$=n(Jd);sb=a(H$,"num_train_timesteps"),H$.forEach(t),ob=a(le,". They can be accessed via "),Xd=o(le,"CODE",{});var G$=n(Xd);nb=a(G$,"scheduler.config.num_train_timesteps"),G$.forEach(t),ib=a(le,`.
`),Zn=o(le,"A",{href:!0});var z$=n(Zn);ab=a(z$,"~ConfigMixin"),z$.forEach(t),db=a(le," also provides general loading and saving functionality via the "),ei=o(le,"A",{href:!0});var Y$=n(ei);lb=a(Y$,"save_config()"),Y$.forEach(t),cb=a(le,` and
`),ti=o(le,"A",{href:!0});var J$=n(ti);ub=a(J$,"from_config()"),J$.forEach(t),pb=a(le," functions."),le.forEach(t),fb=c(be),ri=o(be,"P",{});var lS=n(ri);hb=a(lS,"For more details, see the original paper: "),mo=o(lS,"A",{href:!0,rel:!0});var X$=n(mo);mb=a(X$,"https://arxiv.org/abs/2202.09778"),X$.forEach(t),lS.forEach(t),gb=c(be),ur=o(be,"DIV",{class:!0});var fp=n(ur);h(go.$$.fragment,fp),_b=c(fp),Zd=o(fp,"P",{});var Z$=n(Zd);vb=a(Z$,`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),Z$.forEach(t),fp.forEach(t),bb=c(be),pr=o(be,"DIV",{class:!0});var hp=n(pr);h(_o.$$.fragment,hp),Sb=c(hp),el=o(hp,"P",{});var eE=n(el);Db=a(eE,"Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference."),eE.forEach(t),hp.forEach(t),xb=c(be),fr=o(be,"DIV",{class:!0});var mp=n(fr);h(vo.$$.fragment,mp),$b=c(mp),tl=o(mp,"P",{});var tE=n(tl);Eb=a(tE,`Step function propagating the sample with the linear multi-step method. This has one forward pass with multiple
times to approximate the solution.`),tE.forEach(t),mp.forEach(t),be.forEach(t),Wc=c(r),ot=o(r,"H4",{class:!0});var gp=n(ot);hr=o(gp,"A",{id:!0,class:!0,href:!0});var rE=n(hr);rl=o(rE,"SPAN",{});var sE=n(rl);h(bo.$$.fragment,sE),sE.forEach(t),rE.forEach(t),yb=c(gp),sl=o(gp,"SPAN",{});var oE=n(sl);wb=a(oE,"variance preserving stochastic differential equation (VP-SDE) scheduler"),oE.forEach(t),gp.forEach(t),Uc=c(r),mr=o(r,"P",{});var _p=n(mr);Mb=a(_p,"Original paper can be found "),So=o(_p,"A",{href:!0,rel:!0});var nE=n(So);Pb=a(nE,"here"),nE.forEach(t),Tb=a(_p,"."),_p.forEach(t),Bc=c(r),h(gr.$$.fragment,r),Hc=c(r),te=o(r,"DIV",{class:!0});var Ne=n(te);h(Do.$$.fragment,Ne),Cb=c(Ne),ol=o(Ne,"P",{});var iE=n(ol);kb=a(iE,"The variance preserving stochastic differential equation (SDE) scheduler."),iE.forEach(t),Ob=c(Ne),R=o(Ne,"P",{});var ce=n(R);si=o(ce,"A",{href:!0});var aE=n(si);Ab=a(aE,"~ConfigMixin"),aE.forEach(t),Vb=a(ce," takes care of storing all config attributes that are passed in the scheduler\u2019s "),nl=o(ce,"CODE",{});var dE=n(nl);Fb=a(dE,"__init__"),dE.forEach(t),Ib=a(ce,`
function, such as `),il=o(ce,"CODE",{});var lE=n(il);Nb=a(lE,"num_train_timesteps"),lE.forEach(t),Lb=a(ce,". They can be accessed via "),al=o(ce,"CODE",{});var cE=n(al);qb=a(cE,"scheduler.config.num_train_timesteps"),cE.forEach(t),Kb=a(ce,`.
`),oi=o(ce,"A",{href:!0});var uE=n(oi);Rb=a(uE,"~ConfigMixin"),uE.forEach(t),Qb=a(ce," also provides general loading and saving functionality via the "),ni=o(ce,"A",{href:!0});var pE=n(ni);jb=a(pE,"save_config()"),pE.forEach(t),Wb=a(ce,` and
`),ii=o(ce,"A",{href:!0});var fE=n(ii);Ub=a(fE,"from_config()"),fE.forEach(t),Bb=a(ce," functions."),ce.forEach(t),Hb=c(Ne),ai=o(Ne,"P",{});var cS=n(ai);Gb=a(cS,"For more information, see the original paper: "),xo=o(cS,"A",{href:!0,rel:!0});var hE=n(xo);zb=a(hE,"https://arxiv.org/abs/2011.13456"),hE.forEach(t),cS.forEach(t),Yb=c(Ne),dl=o(Ne,"P",{});var mE=n(dl);Jb=a(mE,"UNDER CONSTRUCTION"),mE.forEach(t),Ne.forEach(t),Gc=c(r),nt=o(r,"H4",{class:!0});var vp=n(nt);_r=o(vp,"A",{id:!0,class:!0,href:!0});var gE=n(_r);ll=o(gE,"SPAN",{});var _E=n(ll);h($o.$$.fragment,_E),_E.forEach(t),gE.forEach(t),Xb=c(vp),cl=o(vp,"SPAN",{});var vE=n(cl);Zb=a(vE,"Euler scheduler"),vE.forEach(t),vp.forEach(t),zc=c(r),Fe=o(r,"P",{});var Ni=n(Fe);e0=a(Ni,"Euler scheduler (Algorithm 2) from the paper "),Eo=o(Ni,"A",{href:!0,rel:!0});var bE=n(Eo);t0=a(bE,"Elucidating the Design Space of Diffusion-Based Generative Models"),bE.forEach(t),r0=a(Ni," by Karras et al. (2022). Based on the original "),yo=o(Ni,"A",{href:!0,rel:!0});var SE=n(yo);s0=a(SE,"k-diffusion"),SE.forEach(t),o0=a(Ni,` implementation by Katherine Crowson.
Fast scheduler which often times generates good outputs with 20-30 steps.`),Ni.forEach(t),Yc=c(r),Y=o(r,"DIV",{class:!0});var Ee=n(Y);h(wo.$$.fragment,Ee),n0=c(Ee),vr=o(Ee,"P",{});var ec=n(vr);i0=a(ec,"Euler scheduler (Algorithm 2) from Karras et al. (2022) "),Mo=o(ec,"A",{href:!0,rel:!0});var DE=n(Mo);a0=a(DE,"https://arxiv.org/abs/2206.00364"),DE.forEach(t),d0=a(ec,`. . Based on the original
k-diffusion implementation by Katherine Crowson:
`),Po=o(ec,"A",{href:!0,rel:!0});var xE=n(Po);l0=a(xE,"https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L51"),xE.forEach(t),ec.forEach(t),c0=c(Ee),Q=o(Ee,"P",{});var ue=n(Q);di=o(ue,"A",{href:!0});var $E=n(di);u0=a($E,"~ConfigMixin"),$E.forEach(t),p0=a(ue," takes care of storing all config attributes that are passed in the scheduler\u2019s "),ul=o(ue,"CODE",{});var EE=n(ul);f0=a(EE,"__init__"),EE.forEach(t),h0=a(ue,`
function, such as `),pl=o(ue,"CODE",{});var yE=n(pl);m0=a(yE,"num_train_timesteps"),yE.forEach(t),g0=a(ue,". They can be accessed via "),fl=o(ue,"CODE",{});var wE=n(fl);_0=a(wE,"scheduler.config.num_train_timesteps"),wE.forEach(t),v0=a(ue,`.
`),li=o(ue,"A",{href:!0});var ME=n(li);b0=a(ME,"~ConfigMixin"),ME.forEach(t),S0=a(ue," also provides general loading and saving functionality via the "),ci=o(ue,"A",{href:!0});var PE=n(ci);D0=a(PE,"save_config()"),PE.forEach(t),x0=a(ue,` and
`),ui=o(ue,"A",{href:!0});var TE=n(ui);$0=a(TE,"from_config()"),TE.forEach(t),E0=a(ue," functions."),ue.forEach(t),y0=c(Ee),br=o(Ee,"DIV",{class:!0});var bp=n(br);h(To.$$.fragment,bp),w0=c(bp),Co=o(bp,"P",{});var Sp=n(Co);M0=a(Sp,"Scales the denoising model input by "),hl=o(Sp,"CODE",{});var CE=n(hl);P0=a(CE,"(sigma**2 + 1) ** 0.5"),CE.forEach(t),T0=a(Sp," to match the Euler algorithm."),Sp.forEach(t),bp.forEach(t),C0=c(Ee),Sr=o(Ee,"DIV",{class:!0});var Dp=n(Sr);h(ko.$$.fragment,Dp),k0=c(Dp),ml=o(Dp,"P",{});var kE=n(ml);O0=a(kE,"Sets the timesteps used for the diffusion chain. Supporting function to be run before inference."),kE.forEach(t),Dp.forEach(t),A0=c(Ee),Dr=o(Ee,"DIV",{class:!0});var xp=n(Dr);h(Oo.$$.fragment,xp),V0=c(xp),gl=o(xp,"P",{});var OE=n(gl);F0=a(OE,`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),OE.forEach(t),xp.forEach(t),Ee.forEach(t),Jc=c(r),it=o(r,"H4",{class:!0});var $p=n(it);xr=o($p,"A",{id:!0,class:!0,href:!0});var AE=n(xr);_l=o(AE,"SPAN",{});var VE=n(_l);h(Ao.$$.fragment,VE),VE.forEach(t),AE.forEach(t),I0=c($p),vl=o($p,"SPAN",{});var FE=n(vl);N0=a(FE,"Euler Ancestral scheduler"),FE.forEach(t),$p.forEach(t),Xc=c(r),pi=o(r,"P",{});var IE=n(pi);L0=a(IE,`Ancestral sampling with Euler method steps. Based on the original (k-diffusion)[https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L72] implementation by Katherine Crowson.
Fast scheduler which often times generates good outputs with 20-30 steps.`),IE.forEach(t),Zc=c(r),J=o(r,"DIV",{class:!0});var ye=n(J);h(Vo.$$.fragment,ye),q0=c(ye),fi=o(ye,"P",{});var uS=n(fi);K0=a(uS,`Ancestral sampling with Euler method steps. Based on the original k-diffusion implementation by Katherine Crowson:
`),Fo=o(uS,"A",{href:!0,rel:!0});var NE=n(Fo);R0=a(NE,"https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L72"),NE.forEach(t),uS.forEach(t),Q0=c(ye),j=o(ye,"P",{});var pe=n(j);hi=o(pe,"A",{href:!0});var LE=n(hi);j0=a(LE,"~ConfigMixin"),LE.forEach(t),W0=a(pe," takes care of storing all config attributes that are passed in the scheduler\u2019s "),bl=o(pe,"CODE",{});var qE=n(bl);U0=a(qE,"__init__"),qE.forEach(t),B0=a(pe,`
function, such as `),Sl=o(pe,"CODE",{});var KE=n(Sl);H0=a(KE,"num_train_timesteps"),KE.forEach(t),G0=a(pe,". They can be accessed via "),Dl=o(pe,"CODE",{});var RE=n(Dl);z0=a(RE,"scheduler.config.num_train_timesteps"),RE.forEach(t),Y0=a(pe,`.
`),mi=o(pe,"A",{href:!0});var QE=n(mi);J0=a(QE,"~ConfigMixin"),QE.forEach(t),X0=a(pe," also provides general loading and saving functionality via the "),gi=o(pe,"A",{href:!0});var jE=n(gi);Z0=a(jE,"save_config()"),jE.forEach(t),e2=a(pe,` and
`),_i=o(pe,"A",{href:!0});var WE=n(_i);t2=a(WE,"from_config()"),WE.forEach(t),r2=a(pe," functions."),pe.forEach(t),s2=c(ye),$r=o(ye,"DIV",{class:!0});var Ep=n($r);h(Io.$$.fragment,Ep),o2=c(Ep),No=o(Ep,"P",{});var yp=n(No);n2=a(yp,"Scales the denoising model input by "),xl=o(yp,"CODE",{});var UE=n(xl);i2=a(UE,"(sigma**2 + 1) ** 0.5"),UE.forEach(t),a2=a(yp," to match the Euler algorithm."),yp.forEach(t),Ep.forEach(t),d2=c(ye),Er=o(ye,"DIV",{class:!0});var wp=n(Er);h(Lo.$$.fragment,wp),l2=c(wp),$l=o(wp,"P",{});var BE=n($l);c2=a(BE,"Sets the timesteps used for the diffusion chain. Supporting function to be run before inference."),BE.forEach(t),wp.forEach(t),u2=c(ye),yr=o(ye,"DIV",{class:!0});var Mp=n(yr);h(qo.$$.fragment,Mp),p2=c(Mp),El=o(Mp,"P",{});var HE=n(El);f2=a(HE,`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),HE.forEach(t),Mp.forEach(t),ye.forEach(t),eu=c(r),at=o(r,"H4",{class:!0});var Pp=n(at);wr=o(Pp,"A",{id:!0,class:!0,href:!0});var GE=n(wr);yl=o(GE,"SPAN",{});var zE=n(yl);h(Ko.$$.fragment,zE),zE.forEach(t),GE.forEach(t),h2=c(Pp),wl=o(Pp,"SPAN",{});var YE=n(wl);m2=a(YE,"VQDiffusionScheduler"),YE.forEach(t),Pp.forEach(t),tu=c(r),Ro=o(r,"P",{});var pS=n(Ro);g2=a(pS,"Original paper can be found "),Qo=o(pS,"A",{href:!0,rel:!0});var JE=n(Qo);_2=a(JE,"here"),JE.forEach(t),pS.forEach(t),ru=c(r),y=o(r,"DIV",{class:!0});var z=n(y);h(jo.$$.fragment,z),v2=c(z),Ml=o(z,"P",{});var XE=n(Ml);b2=a(XE,"The VQ-diffusion transformer outputs predicted probabilities of the initial unnoised image."),XE.forEach(t),S2=c(z),Pl=o(z,"P",{});var ZE=n(Pl);D2=a(ZE,`The VQ-diffusion scheduler converts the transformer\u2019s output into a sample for the unnoised image at the previous
diffusion timestep.`),ZE.forEach(t),x2=c(z),W=o(z,"P",{});var fe=n(W);vi=o(fe,"A",{href:!0});var e5=n(vi);$2=a(e5,"~ConfigMixin"),e5.forEach(t),E2=a(fe," takes care of storing all config attributes that are passed in the scheduler\u2019s "),Tl=o(fe,"CODE",{});var t5=n(Tl);y2=a(t5,"__init__"),t5.forEach(t),w2=a(fe,`
function, such as `),Cl=o(fe,"CODE",{});var r5=n(Cl);M2=a(r5,"num_train_timesteps"),r5.forEach(t),P2=a(fe,". They can be accessed via "),kl=o(fe,"CODE",{});var s5=n(kl);T2=a(s5,"scheduler.config.num_train_timesteps"),s5.forEach(t),C2=a(fe,`.
`),bi=o(fe,"A",{href:!0});var o5=n(bi);k2=a(o5,"~ConfigMixin"),o5.forEach(t),O2=a(fe," also provides general loading and saving functionality via the "),Si=o(fe,"A",{href:!0});var n5=n(Si);A2=a(n5,"save_config()"),n5.forEach(t),V2=a(fe,` and
`),Di=o(fe,"A",{href:!0});var i5=n(Di);F2=a(i5,"from_config()"),i5.forEach(t),I2=a(fe," functions."),fe.forEach(t),N2=c(z),xi=o(z,"P",{});var fS=n(xi);L2=a(fS,"For more details, see the original paper: "),Wo=o(fS,"A",{href:!0,rel:!0});var a5=n(Wo);q2=a(a5,"https://arxiv.org/abs/2111.14822"),a5.forEach(t),fS.forEach(t),K2=c(z),Ie=o(z,"DIV",{class:!0});var Li=n(Ie);h(Uo.$$.fragment,Li),R2=c(Li),Bo=o(Li,"P",{});var Tp=n(Bo);Q2=a(Tp,`Returns the log probabilities of the rows from the (cumulative or non-cumulative) transition matrix for each
latent pixel in `),Ol=o(Tp,"CODE",{});var d5=n(Ol);j2=a(d5,"x_t"),d5.forEach(t),W2=a(Tp,"."),Tp.forEach(t),U2=c(Li),Al=o(Li,"P",{});var l5=n(Al);B2=a(l5,`See equation (7) for the complete non-cumulative transition matrix. The complete cumulative transition matrix
is the same structure except the parameters (alpha, beta, gamma) are the cumulative analogs.`),l5.forEach(t),Li.forEach(t),H2=c(z),U=o(z,"DIV",{class:!0});var Se=n(U);h(Ho.$$.fragment,Se),G2=c(Se),Go=o(Se,"P",{});var Cp=n(Go);z2=a(Cp,"Calculates the log probabilities for the predicted classes of the image at timestep "),Vl=o(Cp,"CODE",{});var c5=n(Vl);Y2=a(c5,"t-1"),c5.forEach(t),J2=a(Cp,". I.e. Equation (11)."),Cp.forEach(t),X2=c(Se),Fl=o(Se,"P",{});var u5=n(Fl);Z2=a(u5,`Instead of directly computing equation (11), we use Equation (5) to restate Equation (11) in terms of only
forward probabilities.`),u5.forEach(t),e4=c(Se),Il=o(Se,"P",{});var p5=n(Il);t4=a(p5,"Equation (11) stated in terms of forward probabilities via Equation (5):"),p5.forEach(t),r4=c(Se),Nl=o(Se,"P",{});var f5=n(Nl);s4=a(f5,"Where:"),f5.forEach(t),o4=c(Se),Ll=o(Se,"UL",{});var h5=n(Ll);zo=o(h5,"LI",{});var kp=n(zo);n4=a(kp,"the sum is over x"),ql=o(kp,"EM",{});var m5=n(ql);i4=a(m5,"0 = {C_0 \u2026 C"),m5.forEach(t),a4=a(kp,"{k-1}} (classes for x_0)"),kp.forEach(t),h5.forEach(t),d4=c(Se),dt=o(Se,"P",{});var qi=n(dt);l4=a(qi,"p(x"),Kl=o(qi,"EM",{});var g5=n(Kl);c4=a(g5,"{t-1} | x_t) = sum( q(x_t | x"),g5.forEach(t),u4=a(qi,"{t-1}) "),Rl=o(qi,"EM",{});var _5=n(Rl);p4=a(_5,"q(x_{t-1} | x_0)"),_5.forEach(t),f4=a(qi," p(x_0) / q(x_t | x_0) )"),qi.forEach(t),Se.forEach(t),h4=c(z),Mr=o(z,"DIV",{class:!0});var Op=n(Mr);h(Yo.$$.fragment,Op),m4=c(Op),Ql=o(Op,"P",{});var v5=n(Ql);g4=a(v5,"Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference."),v5.forEach(t),Op.forEach(t),_4=c(z),Pr=o(z,"DIV",{class:!0});var Ap=n(Pr);h(Jo.$$.fragment,Ap),v4=c(Ap),Xo=o(Ap,"P",{});var Vp=n(Xo);b4=a(Vp,`Predict the sample at the previous timestep via the reverse transition distribution i.e. Equation (11). See the
docstring for `),jl=o(Vp,"CODE",{});var b5=n(jl);S4=a(b5,"self.q_posterior"),b5.forEach(t),D4=a(Vp," for more in depth docs on how Equation (11) is computed."),Vp.forEach(t),Ap.forEach(t),z.forEach(t),su=c(r),lt=o(r,"H4",{class:!0});var Fp=n(lt);Tr=o(Fp,"A",{id:!0,class:!0,href:!0});var S5=n(Tr);Wl=o(S5,"SPAN",{});var D5=n(Wl);h(Zo.$$.fragment,D5),D5.forEach(t),S5.forEach(t),x4=c(Fp),Ul=o(Fp,"SPAN",{});var x5=n(Ul);$4=a(x5,"RePaint scheduler"),x5.forEach(t),Fp.forEach(t),ou=c(r),Te=o(r,"P",{});var dn=n(Te);E4=a(dn,`DDPM-based inpainting scheduler for unsupervised inpainting with extreme masks.
Intended for use with `),$i=o(dn,"A",{href:!0});var $5=n($i);y4=a($5,"RePaintPipeline"),$5.forEach(t),w4=a(dn,`.
Based on the paper `),en=o(dn,"A",{href:!0,rel:!0});var E5=n(en);M4=a(E5,"RePaint: Inpainting using Denoising Diffusion Probabilistic Models"),E5.forEach(t),P4=a(dn,`
and the original implementation by Andreas Lugmayr et al.: `),tn=o(dn,"A",{href:!0,rel:!0});var y5=n(tn);T4=a(y5,"https://github.com/andreas128/RePaint"),y5.forEach(t),dn.forEach(t),nu=c(r),X=o(r,"DIV",{class:!0});var we=n(X);h(rn.$$.fragment,we),C4=c(we),Bl=o(we,"P",{});var w5=n(Bl);k4=a(w5,"RePaint is a schedule for DDPM inpainting inside a given mask."),w5.forEach(t),O4=c(we),B=o(we,"P",{});var he=n(B);Ei=o(he,"A",{href:!0});var M5=n(Ei);A4=a(M5,"~ConfigMixin"),M5.forEach(t),V4=a(he," takes care of storing all config attributes that are passed in the scheduler\u2019s "),Hl=o(he,"CODE",{});var P5=n(Hl);F4=a(P5,"__init__"),P5.forEach(t),I4=a(he,`
function, such as `),Gl=o(he,"CODE",{});var T5=n(Gl);N4=a(T5,"num_train_timesteps"),T5.forEach(t),L4=a(he,". They can be accessed via "),zl=o(he,"CODE",{});var C5=n(zl);q4=a(C5,"scheduler.config.num_train_timesteps"),C5.forEach(t),K4=a(he,`.
`),yi=o(he,"A",{href:!0});var k5=n(yi);R4=a(k5,"~ConfigMixin"),k5.forEach(t),Q4=a(he," also provides general loading and saving functionality via the "),wi=o(he,"A",{href:!0});var O5=n(wi);j4=a(O5,"save_config()"),O5.forEach(t),W4=a(he,` and
`),Mi=o(he,"A",{href:!0});var A5=n(Mi);U4=a(A5,"from_config()"),A5.forEach(t),B4=a(he," functions."),he.forEach(t),H4=c(we),Pi=o(we,"P",{});var hS=n(Pi);G4=a(hS,"For more details, see the original paper: "),sn=o(hS,"A",{href:!0,rel:!0});var V5=n(sn);z4=a(V5,"https://arxiv.org/pdf/2201.09865.pdf"),V5.forEach(t),hS.forEach(t),Y4=c(we),Cr=o(we,"DIV",{class:!0});var Ip=n(Cr);h(on.$$.fragment,Ip),J4=c(Ip),Yl=o(Ip,"P",{});var F5=n(Yl);X4=a(F5,`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),F5.forEach(t),Ip.forEach(t),Z4=c(we),kr=o(we,"DIV",{class:!0});var Np=n(kr);h(nn.$$.fragment,Np),eS=c(Np),Jl=o(Np,"P",{});var I5=n(Jl);tS=a(I5,`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),I5.forEach(t),Np.forEach(t),we.forEach(t),this.h()},h(){d(Z,"name","hf:doc:metadata"),d(Z,"content",JSON.stringify(U5)),d(De,"id","schedulers"),d(De,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(De,"href","#schedulers"),d(ee,"class","relative group"),d(ut,"id","what-is-a-scheduler"),d(ut,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(ut,"href","#what-is-a-scheduler"),d(Le,"class","relative group"),d(ht,"id","discrete-versus-continuous-schedulers"),d(ht,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(ht,"href","#discrete-versus-continuous-schedulers"),d(Ke,"class","relative group"),d(un,"href","/docs/diffusers/pr_1116/en/api/schedulers#diffusers.DDPMScheduler"),d(pn,"href","/docs/diffusers/pr_1116/en/api/schedulers#diffusers.PNDMScheduler"),d(fn,"href","/docs/diffusers/pr_1116/en/api/schedulers#diffusers.ScoreSdeVeScheduler"),d(mt,"id","designing-reusable-schedulers"),d(mt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(mt,"href","#designing-reusable-schedulers"),d(Re,"class","relative group"),d(_t,"id","api"),d(_t,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(_t,"href","#api"),d(Qe,"class","relative group"),d(gn,"href","/docs/diffusers/pr_1116/en/api/schedulers#diffusers.SchedulerMixin"),d(bt,"id","diffusers.SchedulerMixin"),d(bt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(bt,"href","#diffusers.SchedulerMixin"),d(je,"class","relative group"),d(We,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(St,"id","diffusers.schedulers.scheduling_utils.SchedulerOutput"),d(St,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(St,"href","#diffusers.schedulers.scheduling_utils.SchedulerOutput"),d(Ue,"class","relative group"),d(Be,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Dt,"id","implemented-schedulers"),d(Dt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(Dt,"href","#implemented-schedulers"),d(He,"class","relative group"),d(xt,"id","diffusers.DDIMScheduler"),d(xt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(xt,"href","#diffusers.DDIMScheduler"),d(Ge,"class","relative group"),d(vn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(bn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(Sn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.save_config"),d(Dn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.from_config"),d(Jr,"href","https://arxiv.org/abs/2010.02502"),d(Jr,"rel","nofollow"),d($t,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Et,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(yt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(P,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(wt,"id","diffusers.DDPMScheduler"),d(wt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(wt,"href","#diffusers.DDPMScheduler"),d(ze,"class","relative group"),d(rs,"href","https://arxiv.org/abs/2010.02502"),d(rs,"rel","nofollow"),d($n,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(En,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(yn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.save_config"),d(wn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.from_config"),d(os,"href","https://arxiv.org/abs/2006.11239"),d(os,"rel","nofollow"),d(Pt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Tt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Ct,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(T,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(kt,"id","diffusers.DPMSolverMultistepScheduler"),d(kt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(kt,"href","#diffusers.DPMSolverMultistepScheduler"),d(Ye,"class","relative group"),d(ls,"href","https://arxiv.org/abs/2206.00927"),d(ls,"rel","nofollow"),d(cs,"href","https://arxiv.org/abs/2211.01095"),d(cs,"rel","nofollow"),d(us,"href","https://github.com/LuChengTHU/dpm-solver"),d(us,"rel","nofollow"),d(fs,"href","https://arxiv.org/abs/2206.00927"),d(fs,"rel","nofollow"),d(hs,"href","https://arxiv.org/abs/2211.01095"),d(hs,"rel","nofollow"),d(ms,"href","https://arxiv.org/abs/2205.11487"),d(ms,"rel","nofollow"),d(Pn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(Tn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(Cn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.save_config"),d(kn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.from_config"),d($e,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(bs,"href","https://arxiv.org/abs/2206.00927"),d(bs,"rel","nofollow"),d(ke,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(At,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Vt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Ft,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(It,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Nt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(S,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Lt,"id","diffusers.KarrasVeScheduler"),d(Lt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(Lt,"href","#diffusers.KarrasVeScheduler"),d(Xe,"class","relative group"),d(ws,"href","https://arxiv.org/abs/2006.11239"),d(ws,"rel","nofollow"),d(Ps,"href","https://arxiv.org/abs/2206.00364"),d(Ps,"rel","nofollow"),d(Ts,"href","https://arxiv.org/abs/2011.13456"),d(Ts,"rel","nofollow"),d(On,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(An,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(Vn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.save_config"),d(Fn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.from_config"),d(ks,"href","https://arxiv.org/abs/2206.00364"),d(ks,"rel","nofollow"),d(Oe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Rt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Qt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(jt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Wt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(x,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Ut,"id","diffusers.LMSDiscreteScheduler"),d(Ut,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(Ut,"href","#diffusers.LMSDiscreteScheduler"),d(Ze,"class","relative group"),d(Ls,"href","https://arxiv.org/abs/2206.00364"),d(Ls,"rel","nofollow"),d(Ks,"href","https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L181"),d(Ks,"rel","nofollow"),d(Nn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(Ln,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(qn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.save_config"),d(Kn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.from_config"),d(Ht,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Gt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(zt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Yt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(C,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Jt,"id","diffusers.PNDMScheduler"),d(Jt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(Jt,"href","#diffusers.PNDMScheduler"),d(et,"class","relative group"),d(Hs,"href","https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L181"),d(Hs,"rel","nofollow"),d(Rn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(Qn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(jn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.save_config"),d(Wn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.from_config"),d(zs,"href","https://arxiv.org/abs/2202.09778"),d(zs,"rel","nofollow"),d(Zt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(er,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Ae,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(tr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(rr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d($,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(sr,"id","diffusers.ScoreSdeVeScheduler"),d(sr,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(sr,"href","#diffusers.ScoreSdeVeScheduler"),d(tt,"class","relative group"),d(ro,"href","https://arxiv.org/abs/2011.13456"),d(ro,"rel","nofollow"),d(oo,"href","https://arxiv.org/abs/2011.13456"),d(oo,"rel","nofollow"),d(Hn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(Gn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(zn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.save_config"),d(Yn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.from_config"),d(nr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Ve,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(ir,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(ar,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(dr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(E,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(lr,"id","diffusers.IPNDMScheduler"),d(lr,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(lr,"href","#diffusers.IPNDMScheduler"),d(st,"class","relative group"),d(po,"href","https://github.com/crowsonkb/v-diffusion-pytorch/blob/987f8985e38208345c1959b0ea767a625831cc9b/diffusion/sampling.py#L296"),d(po,"rel","nofollow"),d(ho,"href","https://github.com/crowsonkb/v-diffusion-pytorch/blob/987f8985e38208345c1959b0ea767a625831cc9b/diffusion/sampling.py#L296"),d(ho,"rel","nofollow"),d(Xn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(Zn,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(ei,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.save_config"),d(ti,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.from_config"),d(mo,"href","https://arxiv.org/abs/2202.09778"),d(mo,"rel","nofollow"),d(ur,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(pr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(fr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(k,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(hr,"id","diffusers.schedulers.ScoreSdeVpScheduler"),d(hr,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(hr,"href","#diffusers.schedulers.ScoreSdeVpScheduler"),d(ot,"class","relative group"),d(So,"href","https://arxiv.org/abs/2011.13456"),d(So,"rel","nofollow"),d(si,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(oi,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(ni,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.save_config"),d(ii,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.from_config"),d(xo,"href","https://arxiv.org/abs/2011.13456"),d(xo,"rel","nofollow"),d(te,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(_r,"id","diffusers.EulerDiscreteScheduler"),d(_r,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(_r,"href","#diffusers.EulerDiscreteScheduler"),d(nt,"class","relative group"),d(Eo,"href","https://arxiv.org/abs/2206.00364"),d(Eo,"rel","nofollow"),d(yo,"href","https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L51"),d(yo,"rel","nofollow"),d(Mo,"href","https://arxiv.org/abs/2206.00364"),d(Mo,"rel","nofollow"),d(Po,"href","https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L51"),d(Po,"rel","nofollow"),d(di,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(li,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(ci,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.save_config"),d(ui,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.from_config"),d(br,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Sr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Dr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Y,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(xr,"id","diffusers.EulerAncestralDiscreteScheduler"),d(xr,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(xr,"href","#diffusers.EulerAncestralDiscreteScheduler"),d(it,"class","relative group"),d(Fo,"href","https://github.com/crowsonkb/k-diffusion/blob/481677d114f6ea445aa009cf5bd7a9cdee909e47/k_diffusion/sampling.py#L72"),d(Fo,"rel","nofollow"),d(hi,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(mi,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(gi,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.save_config"),d(_i,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.from_config"),d($r,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Er,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(yr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(J,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(wr,"id","diffusers.VQDiffusionScheduler"),d(wr,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(wr,"href","#diffusers.VQDiffusionScheduler"),d(at,"class","relative group"),d(Qo,"href","https://arxiv.org/abs/2111.14822"),d(Qo,"rel","nofollow"),d(vi,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(bi,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(Si,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.save_config"),d(Di,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.from_config"),d(Wo,"href","https://arxiv.org/abs/2111.14822"),d(Wo,"rel","nofollow"),d(Ie,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(U,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Mr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Pr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(y,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(Tr,"id","diffusers.RePaintScheduler"),d(Tr,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),d(Tr,"href","#diffusers.RePaintScheduler"),d(lt,"class","relative group"),d($i,"href","/docs/diffusers/pr_1116/en/api/pipelines/repaint#diffusers.RePaintPipeline"),d(en,"href","https://arxiv.org/abs/2201.09865"),d(en,"rel","nofollow"),d(tn,"href","https://github.com/andreas128/RePaint"),d(tn,"rel","nofollow"),d(Ei,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(yi,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin"),d(wi,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.save_config"),d(Mi,"href","/docs/diffusers/pr_1116/en/using-diffusers/configuration#diffusers.ConfigMixin.from_config"),d(sn,"href","https://arxiv.org/pdf/2201.09865.pdf"),d(sn,"rel","nofollow"),d(Cr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(kr,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),d(X,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8")},m(r,u){e(document.head,Z),p(r,ct,u),p(r,ee,u),e(ee,De),e(De,Ki),m(Ir,Ki,null),e(ee,Lp),e(ee,Ri),e(Ri,qp),p(r,rc,u),p(r,ln,u),e(ln,Kp),p(r,sc,u),p(r,Le,u),e(Le,ut),e(ut,Qi),m(Nr,Qi,null),e(Le,Rp),e(Le,ji),e(ji,Qp),p(r,oc,u),p(r,pt,u),e(pt,jp),e(pt,Wi),e(Wi,Wp),e(pt,Up),p(r,nc,u),p(r,ft,u),e(ft,cn),e(cn,Bp),e(cn,Lr),e(Lr,Ui),e(Ui,Hp),e(Lr,Gp),e(Lr,Bi),e(Bi,zp),e(ft,Yp),e(ft,qe),e(qe,Jp),e(qe,Hi),e(Hi,Xp),e(qe,Zp),e(qe,Gi),e(Gi,ef),e(qe,tf),p(r,ic,u),p(r,Ke,u),e(Ke,ht),e(ht,zi),m(qr,zi,null),e(Ke,rf),e(Ke,Yi),e(Yi,sf),p(r,ac,u),p(r,O,u),e(O,of),e(O,Ji),e(Ji,nf),e(O,af),e(O,un),e(un,df),e(O,lf),e(O,pn),e(pn,cf),e(O,uf),e(O,Xi),e(Xi,pf),e(O,ff),e(O,fn),e(fn,hf),e(O,mf),e(O,Zi),e(Zi,gf),e(O,_f),p(r,dc,u),p(r,Re,u),e(Re,mt),e(mt,ea),m(Kr,ea,null),e(Re,vf),e(Re,ta),e(ta,bf),p(r,lc,u),p(r,hn,u),e(hn,Sf),p(r,cc,u),p(r,gt,u),e(gt,ra),e(ra,Df),e(gt,xf),e(gt,sa),e(sa,$f),p(r,uc,u),p(r,Qe,u),e(Qe,_t),e(_t,oa),m(Rr,oa,null),e(Qe,Ef),e(Qe,na),e(na,yf),p(r,pc,u),p(r,mn,u),e(mn,wf),p(r,fc,u),p(r,Ce,u),e(Ce,Qr),e(Qr,Mf),e(Qr,ia),e(ia,Pf),e(Qr,Tf),e(Ce,Cf),e(Ce,jr),e(jr,kf),e(jr,aa),e(aa,Of),e(jr,Af),e(Ce,Vf),e(Ce,da),e(da,Ff),p(r,hc,u),p(r,vt,u),e(vt,If),e(vt,gn),e(gn,Nf),e(vt,Lf),p(r,mc,u),p(r,je,u),e(je,bt),e(bt,la),m(Wr,la,null),e(je,qf),e(je,ca),e(ca,Kf),p(r,gc,u),p(r,We,u),m(Ur,We,null),e(We,Rf),e(We,ua),e(ua,Qf),p(r,_c,u),p(r,Ue,u),e(Ue,St),e(St,pa),m(Br,pa,null),e(Ue,jf),e(Ue,fa),e(fa,Wf),p(r,vc,u),p(r,Be,u),m(Hr,Be,null),e(Be,Uf),e(Be,ha),e(ha,Bf),p(r,bc,u),p(r,He,u),e(He,Dt),e(Dt,ma),m(Gr,ma,null),e(He,Hf),e(He,ga),e(ga,Gf),p(r,Sc,u),p(r,Ge,u),e(Ge,xt),e(xt,_a),m(zr,_a,null),e(Ge,zf),e(Ge,va),e(va,Yf),p(r,Dc,u),p(r,_n,u),e(_n,Jf),p(r,xc,u),p(r,P,u),m(Yr,P,null),e(P,Xf),e(P,ba),e(ba,Zf),e(P,eh),e(P,A),e(A,vn),e(vn,th),e(A,rh),e(A,Sa),e(Sa,sh),e(A,oh),e(A,Da),e(Da,nh),e(A,ih),e(A,xa),e(xa,ah),e(A,dh),e(A,bn),e(bn,lh),e(A,ch),e(A,Sn),e(Sn,uh),e(A,ph),e(A,Dn),e(Dn,fh),e(A,hh),e(P,mh),e(P,xn),e(xn,gh),e(xn,Jr),e(Jr,_h),e(P,vh),e(P,$t),m(Xr,$t,null),e($t,bh),e($t,$a),e($a,Sh),e(P,Dh),e(P,Et),m(Zr,Et,null),e(Et,xh),e(Et,Ea),e(Ea,$h),e(P,Eh),e(P,yt),m(es,yt,null),e(yt,yh),e(yt,ya),e(ya,wh),p(r,$c,u),p(r,ze,u),e(ze,wt),e(wt,wa),m(ts,wa,null),e(ze,Mh),e(ze,Ma),e(Ma,Ph),p(r,Ec,u),p(r,Mt,u),e(Mt,Th),e(Mt,rs),e(rs,Ch),e(Mt,kh),p(r,yc,u),p(r,T,u),m(ss,T,null),e(T,Oh),e(T,Pa),e(Pa,Ah),e(T,Vh),e(T,V),e(V,$n),e($n,Fh),e(V,Ih),e(V,Ta),e(Ta,Nh),e(V,Lh),e(V,Ca),e(Ca,qh),e(V,Kh),e(V,ka),e(ka,Rh),e(V,Qh),e(V,En),e(En,jh),e(V,Wh),e(V,yn),e(yn,Uh),e(V,Bh),e(V,wn),e(wn,Hh),e(V,Gh),e(T,zh),e(T,Mn),e(Mn,Yh),e(Mn,os),e(os,Jh),e(T,Xh),e(T,Pt),m(ns,Pt,null),e(Pt,Zh),e(Pt,Oa),e(Oa,em),e(T,tm),e(T,Tt),m(is,Tt,null),e(Tt,rm),e(Tt,Aa),e(Aa,sm),e(T,om),e(T,Ct),m(as,Ct,null),e(Ct,nm),e(Ct,Va),e(Va,im),p(r,wc,u),p(r,Ye,u),e(Ye,kt),e(kt,Fa),m(ds,Fa,null),e(Ye,am),e(Ye,Ia),e(Ia,dm),p(r,Mc,u),p(r,xe,u),e(xe,lm),e(xe,ls),e(ls,cm),e(xe,um),e(xe,cs),e(cs,pm),e(xe,fm),e(xe,us),e(us,hm),e(xe,mm),p(r,Pc,u),p(r,S,u),m(ps,S,null),e(S,gm),e(S,Na),e(Na,_m),e(S,vm),e(S,Ot),e(Ot,bm),e(Ot,fs),e(fs,Sm),e(Ot,Dm),e(Ot,hs),e(hs,xm),e(S,$m),e(S,Je),e(Je,Em),e(Je,La),e(La,ym),e(Je,wm),e(Je,qa),e(qa,Mm),e(Je,Pm),e(S,Tm),e(S,Me),e(Me,Cm),e(Me,ms),e(ms,km),e(Me,Om),e(Me,Ka),e(Ka,Am),e(Me,Vm),e(Me,Ra),e(Ra,Fm),e(Me,Im),e(S,Nm),e(S,F),e(F,Pn),e(Pn,Lm),e(F,qm),e(F,Qa),e(Qa,Km),e(F,Rm),e(F,ja),e(ja,Qm),e(F,jm),e(F,Wa),e(Wa,Wm),e(F,Um),e(F,Tn),e(Tn,Bm),e(F,Hm),e(F,Cn),e(Cn,Gm),e(F,zm),e(F,kn),e(kn,Ym),e(F,Jm),e(S,Xm),e(S,$e),m(gs,$e,null),e($e,Zm),e($e,Ua),e(Ua,eg),e($e,tg),e($e,Ba),e(Ba,rg),e($e,sg),e($e,Ha),e(Ha,og),e(S,ng),e(S,ke),m(_s,ke,null),e(ke,ig),e(ke,Ga),e(Ga,ag),e(ke,dg),e(ke,vs),e(vs,lg),e(vs,bs),e(bs,cg),e(vs,ug),e(S,pg),e(S,At),m(Ss,At,null),e(At,fg),e(At,za),e(za,hg),e(S,mg),e(S,Vt),m(Ds,Vt,null),e(Vt,gg),e(Vt,Ya),e(Ya,_g),e(S,vg),e(S,Ft),m(xs,Ft,null),e(Ft,bg),e(Ft,Ja),e(Ja,Sg),e(S,Dg),e(S,It),m($s,It,null),e(It,xg),e(It,Xa),e(Xa,$g),e(S,Eg),e(S,Nt),m(Es,Nt,null),e(Nt,yg),e(Nt,Za),e(Za,wg),p(r,Tc,u),p(r,Xe,u),e(Xe,Lt),e(Lt,ed),m(ys,ed,null),e(Xe,Mg),e(Xe,td),e(td,Pg),p(r,Cc,u),p(r,qt,u),e(qt,Tg),e(qt,ws),e(ws,Cg),e(qt,kg),p(r,kc,u),p(r,x,u),m(Ms,x,null),e(x,Og),e(x,rd),e(rd,Ag),e(x,Vg),e(x,Kt),e(Kt,Fg),e(Kt,Ps),e(Ps,Ig),e(Kt,Ng),e(Kt,Ts),e(Ts,Lg),e(x,qg),e(x,I),e(I,On),e(On,Kg),e(I,Rg),e(I,sd),e(sd,Qg),e(I,jg),e(I,od),e(od,Wg),e(I,Ug),e(I,nd),e(nd,Bg),e(I,Hg),e(I,An),e(An,Gg),e(I,zg),e(I,Vn),e(Vn,Yg),e(I,Jg),e(I,Fn),e(Fn,Xg),e(I,Zg),e(x,e_),e(x,Cs),e(Cs,t_),e(Cs,ks),e(ks,r_),e(Cs,s_),e(x,o_),e(x,Oe),m(Os,Oe,null),e(Oe,n_),e(Oe,id),e(id,i_),e(Oe,a_),e(Oe,ad),e(ad,d_),e(x,l_),e(x,Rt),m(As,Rt,null),e(Rt,c_),e(Rt,dd),e(dd,u_),e(x,p_),e(x,Qt),m(Vs,Qt,null),e(Qt,f_),e(Qt,ld),e(ld,h_),e(x,m_),e(x,jt),m(Fs,jt,null),e(jt,g_),e(jt,cd),e(cd,__),e(x,v_),e(x,Wt),m(Is,Wt,null),e(Wt,b_),e(Wt,ud),e(ud,S_),p(r,Oc,u),p(r,Ze,u),e(Ze,Ut),e(Ut,pd),m(Ns,pd,null),e(Ze,D_),e(Ze,fd),e(fd,x_),p(r,Ac,u),p(r,Bt,u),e(Bt,$_),e(Bt,Ls),e(Ls,E_),e(Bt,y_),p(r,Vc,u),p(r,C,u),m(qs,C,null),e(C,w_),e(C,In),e(In,M_),e(In,Ks),e(Ks,P_),e(C,T_),e(C,N),e(N,Nn),e(Nn,C_),e(N,k_),e(N,hd),e(hd,O_),e(N,A_),e(N,md),e(md,V_),e(N,F_),e(N,gd),e(gd,I_),e(N,N_),e(N,Ln),e(Ln,L_),e(N,q_),e(N,qn),e(qn,K_),e(N,R_),e(N,Kn),e(Kn,Q_),e(N,j_),e(C,W_),e(C,Ht),m(Rs,Ht,null),e(Ht,U_),e(Ht,_d),e(_d,B_),e(C,H_),e(C,Gt),m(Qs,Gt,null),e(Gt,G_),e(Gt,js),e(js,z_),e(js,vd),e(vd,Y_),e(js,J_),e(C,X_),e(C,zt),m(Ws,zt,null),e(zt,Z_),e(zt,bd),e(bd,ev),e(C,tv),e(C,Yt),m(Us,Yt,null),e(Yt,rv),e(Yt,Sd),e(Sd,sv),p(r,Fc,u),p(r,et,u),e(et,Jt),e(Jt,Dd),m(Bs,Dd,null),e(et,ov),e(et,xd),e(xd,nv),p(r,Ic,u),p(r,Xt,u),e(Xt,iv),e(Xt,Hs),e(Hs,av),e(Xt,dv),p(r,Nc,u),p(r,$,u),m(Gs,$,null),e($,lv),e($,$d),e($d,cv),e($,uv),e($,L),e(L,Rn),e(Rn,pv),e(L,fv),e(L,Ed),e(Ed,hv),e(L,mv),e(L,yd),e(yd,gv),e(L,_v),e(L,wd),e(wd,vv),e(L,bv),e(L,Qn),e(Qn,Sv),e(L,Dv),e(L,jn),e(jn,xv),e(L,$v),e(L,Wn),e(Wn,Ev),e(L,yv),e($,wv),e($,Un),e(Un,Mv),e(Un,zs),e(zs,Pv),e($,Tv),e($,Zt),m(Ys,Zt,null),e(Zt,Cv),e(Zt,Md),e(Md,kv),e($,Ov),e($,er),m(Js,er,null),e(er,Av),e(er,Pd),e(Pd,Vv),e($,Fv),e($,Ae),m(Xs,Ae,null),e(Ae,Iv),e(Ae,Td),e(Td,Nv),e(Ae,Lv),e(Ae,Pe),e(Pe,qv),e(Pe,Cd),e(Cd,Kv),e(Pe,Rv),e(Pe,kd),e(kd,Qv),e(Pe,jv),e(Pe,Od),e(Od,Wv),e(Pe,Uv),e($,Bv),e($,tr),m(Zs,tr,null),e(tr,Hv),e(tr,Ad),e(Ad,Gv),e($,zv),e($,rr),m(eo,rr,null),e(rr,Yv),e(rr,Vd),e(Vd,Jv),p(r,Lc,u),p(r,tt,u),e(tt,sr),e(sr,Fd),m(to,Fd,null),e(tt,Xv),e(tt,Id),e(Id,Zv),p(r,qc,u),p(r,or,u),e(or,e1),e(or,ro),e(ro,t1),e(or,r1),p(r,Kc,u),p(r,E,u),m(so,E,null),e(E,s1),e(E,Nd),e(Nd,o1),e(E,n1),e(E,Bn),e(Bn,i1),e(Bn,oo),e(oo,a1),e(E,d1),e(E,q),e(q,Hn),e(Hn,l1),e(q,c1),e(q,Ld),e(Ld,u1),e(q,p1),e(q,qd),e(qd,f1),e(q,h1),e(q,Kd),e(Kd,m1),e(q,g1),e(q,Gn),e(Gn,_1),e(q,v1),e(q,zn),e(zn,b1),e(q,S1),e(q,Yn),e(Yn,D1),e(q,x1),e(E,$1),e(E,nr),m(no,nr,null),e(nr,E1),e(nr,Rd),e(Rd,y1),e(E,w1),e(E,Ve),m(io,Ve,null),e(Ve,M1),e(Ve,Qd),e(Qd,P1),e(Ve,T1),e(Ve,rt),e(rt,C1),e(rt,jd),e(jd,k1),e(rt,O1),e(rt,Wd),e(Wd,A1),e(rt,V1),e(E,F1),e(E,ir),m(ao,ir,null),e(ir,I1),e(ir,Ud),e(Ud,N1),e(E,L1),e(E,ar),m(lo,ar,null),e(ar,q1),e(ar,Bd),e(Bd,K1),e(E,R1),e(E,dr),m(co,dr,null),e(dr,Q1),e(dr,Hd),e(Hd,j1),p(r,Rc,u),p(r,st,u),e(st,lr),e(lr,Gd),m(uo,Gd,null),e(st,W1),e(st,zd),e(zd,U1),p(r,Qc,u),p(r,cr,u),e(cr,B1),e(cr,po),e(po,H1),e(cr,G1),p(r,jc,u),p(r,k,u),m(fo,k,null),e(k,z1),e(k,Jn),e(Jn,Y1),e(Jn,ho),e(ho,J1),e(k,X1),e(k,K),e(K,Xn),e(Xn,Z1),e(K,eb),e(K,Yd),e(Yd,tb),e(K,rb),e(K,Jd),e(Jd,sb),e(K,ob),e(K,Xd),e(Xd,nb),e(K,ib),e(K,Zn),e(Zn,ab),e(K,db),e(K,ei),e(ei,lb),e(K,cb),e(K,ti),e(ti,ub),e(K,pb),e(k,fb),e(k,ri),e(ri,hb),e(ri,mo),e(mo,mb),e(k,gb),e(k,ur),m(go,ur,null),e(ur,_b),e(ur,Zd),e(Zd,vb),e(k,bb),e(k,pr),m(_o,pr,null),e(pr,Sb),e(pr,el),e(el,Db),e(k,xb),e(k,fr),m(vo,fr,null),e(fr,$b),e(fr,tl),e(tl,Eb),p(r,Wc,u),p(r,ot,u),e(ot,hr),e(hr,rl),m(bo,rl,null),e(ot,yb),e(ot,sl),e(sl,wb),p(r,Uc,u),p(r,mr,u),e(mr,Mb),e(mr,So),e(So,Pb),e(mr,Tb),p(r,Bc,u),m(gr,r,u),p(r,Hc,u),p(r,te,u),m(Do,te,null),e(te,Cb),e(te,ol),e(ol,kb),e(te,Ob),e(te,R),e(R,si),e(si,Ab),e(R,Vb),e(R,nl),e(nl,Fb),e(R,Ib),e(R,il),e(il,Nb),e(R,Lb),e(R,al),e(al,qb),e(R,Kb),e(R,oi),e(oi,Rb),e(R,Qb),e(R,ni),e(ni,jb),e(R,Wb),e(R,ii),e(ii,Ub),e(R,Bb),e(te,Hb),e(te,ai),e(ai,Gb),e(ai,xo),e(xo,zb),e(te,Yb),e(te,dl),e(dl,Jb),p(r,Gc,u),p(r,nt,u),e(nt,_r),e(_r,ll),m($o,ll,null),e(nt,Xb),e(nt,cl),e(cl,Zb),p(r,zc,u),p(r,Fe,u),e(Fe,e0),e(Fe,Eo),e(Eo,t0),e(Fe,r0),e(Fe,yo),e(yo,s0),e(Fe,o0),p(r,Yc,u),p(r,Y,u),m(wo,Y,null),e(Y,n0),e(Y,vr),e(vr,i0),e(vr,Mo),e(Mo,a0),e(vr,d0),e(vr,Po),e(Po,l0),e(Y,c0),e(Y,Q),e(Q,di),e(di,u0),e(Q,p0),e(Q,ul),e(ul,f0),e(Q,h0),e(Q,pl),e(pl,m0),e(Q,g0),e(Q,fl),e(fl,_0),e(Q,v0),e(Q,li),e(li,b0),e(Q,S0),e(Q,ci),e(ci,D0),e(Q,x0),e(Q,ui),e(ui,$0),e(Q,E0),e(Y,y0),e(Y,br),m(To,br,null),e(br,w0),e(br,Co),e(Co,M0),e(Co,hl),e(hl,P0),e(Co,T0),e(Y,C0),e(Y,Sr),m(ko,Sr,null),e(Sr,k0),e(Sr,ml),e(ml,O0),e(Y,A0),e(Y,Dr),m(Oo,Dr,null),e(Dr,V0),e(Dr,gl),e(gl,F0),p(r,Jc,u),p(r,it,u),e(it,xr),e(xr,_l),m(Ao,_l,null),e(it,I0),e(it,vl),e(vl,N0),p(r,Xc,u),p(r,pi,u),e(pi,L0),p(r,Zc,u),p(r,J,u),m(Vo,J,null),e(J,q0),e(J,fi),e(fi,K0),e(fi,Fo),e(Fo,R0),e(J,Q0),e(J,j),e(j,hi),e(hi,j0),e(j,W0),e(j,bl),e(bl,U0),e(j,B0),e(j,Sl),e(Sl,H0),e(j,G0),e(j,Dl),e(Dl,z0),e(j,Y0),e(j,mi),e(mi,J0),e(j,X0),e(j,gi),e(gi,Z0),e(j,e2),e(j,_i),e(_i,t2),e(j,r2),e(J,s2),e(J,$r),m(Io,$r,null),e($r,o2),e($r,No),e(No,n2),e(No,xl),e(xl,i2),e(No,a2),e(J,d2),e(J,Er),m(Lo,Er,null),e(Er,l2),e(Er,$l),e($l,c2),e(J,u2),e(J,yr),m(qo,yr,null),e(yr,p2),e(yr,El),e(El,f2),p(r,eu,u),p(r,at,u),e(at,wr),e(wr,yl),m(Ko,yl,null),e(at,h2),e(at,wl),e(wl,m2),p(r,tu,u),p(r,Ro,u),e(Ro,g2),e(Ro,Qo),e(Qo,_2),p(r,ru,u),p(r,y,u),m(jo,y,null),e(y,v2),e(y,Ml),e(Ml,b2),e(y,S2),e(y,Pl),e(Pl,D2),e(y,x2),e(y,W),e(W,vi),e(vi,$2),e(W,E2),e(W,Tl),e(Tl,y2),e(W,w2),e(W,Cl),e(Cl,M2),e(W,P2),e(W,kl),e(kl,T2),e(W,C2),e(W,bi),e(bi,k2),e(W,O2),e(W,Si),e(Si,A2),e(W,V2),e(W,Di),e(Di,F2),e(W,I2),e(y,N2),e(y,xi),e(xi,L2),e(xi,Wo),e(Wo,q2),e(y,K2),e(y,Ie),m(Uo,Ie,null),e(Ie,R2),e(Ie,Bo),e(Bo,Q2),e(Bo,Ol),e(Ol,j2),e(Bo,W2),e(Ie,U2),e(Ie,Al),e(Al,B2),e(y,H2),e(y,U),m(Ho,U,null),e(U,G2),e(U,Go),e(Go,z2),e(Go,Vl),e(Vl,Y2),e(Go,J2),e(U,X2),e(U,Fl),e(Fl,Z2),e(U,e4),e(U,Il),e(Il,t4),e(U,r4),e(U,Nl),e(Nl,s4),e(U,o4),e(U,Ll),e(Ll,zo),e(zo,n4),e(zo,ql),e(ql,i4),e(zo,a4),e(U,d4),e(U,dt),e(dt,l4),e(dt,Kl),e(Kl,c4),e(dt,u4),e(dt,Rl),e(Rl,p4),e(dt,f4),e(y,h4),e(y,Mr),m(Yo,Mr,null),e(Mr,m4),e(Mr,Ql),e(Ql,g4),e(y,_4),e(y,Pr),m(Jo,Pr,null),e(Pr,v4),e(Pr,Xo),e(Xo,b4),e(Xo,jl),e(jl,S4),e(Xo,D4),p(r,su,u),p(r,lt,u),e(lt,Tr),e(Tr,Wl),m(Zo,Wl,null),e(lt,x4),e(lt,Ul),e(Ul,$4),p(r,ou,u),p(r,Te,u),e(Te,E4),e(Te,$i),e($i,y4),e(Te,w4),e(Te,en),e(en,M4),e(Te,P4),e(Te,tn),e(tn,T4),p(r,nu,u),p(r,X,u),m(rn,X,null),e(X,C4),e(X,Bl),e(Bl,k4),e(X,O4),e(X,B),e(B,Ei),e(Ei,A4),e(B,V4),e(B,Hl),e(Hl,F4),e(B,I4),e(B,Gl),e(Gl,N4),e(B,L4),e(B,zl),e(zl,q4),e(B,K4),e(B,yi),e(yi,R4),e(B,Q4),e(B,wi),e(wi,j4),e(B,W4),e(B,Mi),e(Mi,U4),e(B,B4),e(X,H4),e(X,Pi),e(Pi,G4),e(Pi,sn),e(sn,z4),e(X,Y4),e(X,Cr),m(on,Cr,null),e(Cr,J4),e(Cr,Yl),e(Yl,X4),e(X,Z4),e(X,kr),m(nn,kr,null),e(kr,eS),e(kr,Jl),e(Jl,tS),iu=!0},p(r,[u]){const an={};u&2&&(an.$$scope={dirty:u,ctx:r}),gr.$set(an)},i(r){iu||(g(Ir.$$.fragment,r),g(Nr.$$.fragment,r),g(qr.$$.fragment,r),g(Kr.$$.fragment,r),g(Rr.$$.fragment,r),g(Wr.$$.fragment,r),g(Ur.$$.fragment,r),g(Br.$$.fragment,r),g(Hr.$$.fragment,r),g(Gr.$$.fragment,r),g(zr.$$.fragment,r),g(Yr.$$.fragment,r),g(Xr.$$.fragment,r),g(Zr.$$.fragment,r),g(es.$$.fragment,r),g(ts.$$.fragment,r),g(ss.$$.fragment,r),g(ns.$$.fragment,r),g(is.$$.fragment,r),g(as.$$.fragment,r),g(ds.$$.fragment,r),g(ps.$$.fragment,r),g(gs.$$.fragment,r),g(_s.$$.fragment,r),g(Ss.$$.fragment,r),g(Ds.$$.fragment,r),g(xs.$$.fragment,r),g($s.$$.fragment,r),g(Es.$$.fragment,r),g(ys.$$.fragment,r),g(Ms.$$.fragment,r),g(Os.$$.fragment,r),g(As.$$.fragment,r),g(Vs.$$.fragment,r),g(Fs.$$.fragment,r),g(Is.$$.fragment,r),g(Ns.$$.fragment,r),g(qs.$$.fragment,r),g(Rs.$$.fragment,r),g(Qs.$$.fragment,r),g(Ws.$$.fragment,r),g(Us.$$.fragment,r),g(Bs.$$.fragment,r),g(Gs.$$.fragment,r),g(Ys.$$.fragment,r),g(Js.$$.fragment,r),g(Xs.$$.fragment,r),g(Zs.$$.fragment,r),g(eo.$$.fragment,r),g(to.$$.fragment,r),g(so.$$.fragment,r),g(no.$$.fragment,r),g(io.$$.fragment,r),g(ao.$$.fragment,r),g(lo.$$.fragment,r),g(co.$$.fragment,r),g(uo.$$.fragment,r),g(fo.$$.fragment,r),g(go.$$.fragment,r),g(_o.$$.fragment,r),g(vo.$$.fragment,r),g(bo.$$.fragment,r),g(gr.$$.fragment,r),g(Do.$$.fragment,r),g($o.$$.fragment,r),g(wo.$$.fragment,r),g(To.$$.fragment,r),g(ko.$$.fragment,r),g(Oo.$$.fragment,r),g(Ao.$$.fragment,r),g(Vo.$$.fragment,r),g(Io.$$.fragment,r),g(Lo.$$.fragment,r),g(qo.$$.fragment,r),g(Ko.$$.fragment,r),g(jo.$$.fragment,r),g(Uo.$$.fragment,r),g(Ho.$$.fragment,r),g(Yo.$$.fragment,r),g(Jo.$$.fragment,r),g(Zo.$$.fragment,r),g(rn.$$.fragment,r),g(on.$$.fragment,r),g(nn.$$.fragment,r),iu=!0)},o(r){_(Ir.$$.fragment,r),_(Nr.$$.fragment,r),_(qr.$$.fragment,r),_(Kr.$$.fragment,r),_(Rr.$$.fragment,r),_(Wr.$$.fragment,r),_(Ur.$$.fragment,r),_(Br.$$.fragment,r),_(Hr.$$.fragment,r),_(Gr.$$.fragment,r),_(zr.$$.fragment,r),_(Yr.$$.fragment,r),_(Xr.$$.fragment,r),_(Zr.$$.fragment,r),_(es.$$.fragment,r),_(ts.$$.fragment,r),_(ss.$$.fragment,r),_(ns.$$.fragment,r),_(is.$$.fragment,r),_(as.$$.fragment,r),_(ds.$$.fragment,r),_(ps.$$.fragment,r),_(gs.$$.fragment,r),_(_s.$$.fragment,r),_(Ss.$$.fragment,r),_(Ds.$$.fragment,r),_(xs.$$.fragment,r),_($s.$$.fragment,r),_(Es.$$.fragment,r),_(ys.$$.fragment,r),_(Ms.$$.fragment,r),_(Os.$$.fragment,r),_(As.$$.fragment,r),_(Vs.$$.fragment,r),_(Fs.$$.fragment,r),_(Is.$$.fragment,r),_(Ns.$$.fragment,r),_(qs.$$.fragment,r),_(Rs.$$.fragment,r),_(Qs.$$.fragment,r),_(Ws.$$.fragment,r),_(Us.$$.fragment,r),_(Bs.$$.fragment,r),_(Gs.$$.fragment,r),_(Ys.$$.fragment,r),_(Js.$$.fragment,r),_(Xs.$$.fragment,r),_(Zs.$$.fragment,r),_(eo.$$.fragment,r),_(to.$$.fragment,r),_(so.$$.fragment,r),_(no.$$.fragment,r),_(io.$$.fragment,r),_(ao.$$.fragment,r),_(lo.$$.fragment,r),_(co.$$.fragment,r),_(uo.$$.fragment,r),_(fo.$$.fragment,r),_(go.$$.fragment,r),_(_o.$$.fragment,r),_(vo.$$.fragment,r),_(bo.$$.fragment,r),_(gr.$$.fragment,r),_(Do.$$.fragment,r),_($o.$$.fragment,r),_(wo.$$.fragment,r),_(To.$$.fragment,r),_(ko.$$.fragment,r),_(Oo.$$.fragment,r),_(Ao.$$.fragment,r),_(Vo.$$.fragment,r),_(Io.$$.fragment,r),_(Lo.$$.fragment,r),_(qo.$$.fragment,r),_(Ko.$$.fragment,r),_(jo.$$.fragment,r),_(Uo.$$.fragment,r),_(Ho.$$.fragment,r),_(Yo.$$.fragment,r),_(Jo.$$.fragment,r),_(Zo.$$.fragment,r),_(rn.$$.fragment,r),_(on.$$.fragment,r),_(nn.$$.fragment,r),iu=!1},d(r){t(Z),r&&t(ct),r&&t(ee),v(Ir),r&&t(rc),r&&t(ln),r&&t(sc),r&&t(Le),v(Nr),r&&t(oc),r&&t(pt),r&&t(nc),r&&t(ft),r&&t(ic),r&&t(Ke),v(qr),r&&t(ac),r&&t(O),r&&t(dc),r&&t(Re),v(Kr),r&&t(lc),r&&t(hn),r&&t(cc),r&&t(gt),r&&t(uc),r&&t(Qe),v(Rr),r&&t(pc),r&&t(mn),r&&t(fc),r&&t(Ce),r&&t(hc),r&&t(vt),r&&t(mc),r&&t(je),v(Wr),r&&t(gc),r&&t(We),v(Ur),r&&t(_c),r&&t(Ue),v(Br),r&&t(vc),r&&t(Be),v(Hr),r&&t(bc),r&&t(He),v(Gr),r&&t(Sc),r&&t(Ge),v(zr),r&&t(Dc),r&&t(_n),r&&t(xc),r&&t(P),v(Yr),v(Xr),v(Zr),v(es),r&&t($c),r&&t(ze),v(ts),r&&t(Ec),r&&t(Mt),r&&t(yc),r&&t(T),v(ss),v(ns),v(is),v(as),r&&t(wc),r&&t(Ye),v(ds),r&&t(Mc),r&&t(xe),r&&t(Pc),r&&t(S),v(ps),v(gs),v(_s),v(Ss),v(Ds),v(xs),v($s),v(Es),r&&t(Tc),r&&t(Xe),v(ys),r&&t(Cc),r&&t(qt),r&&t(kc),r&&t(x),v(Ms),v(Os),v(As),v(Vs),v(Fs),v(Is),r&&t(Oc),r&&t(Ze),v(Ns),r&&t(Ac),r&&t(Bt),r&&t(Vc),r&&t(C),v(qs),v(Rs),v(Qs),v(Ws),v(Us),r&&t(Fc),r&&t(et),v(Bs),r&&t(Ic),r&&t(Xt),r&&t(Nc),r&&t($),v(Gs),v(Ys),v(Js),v(Xs),v(Zs),v(eo),r&&t(Lc),r&&t(tt),v(to),r&&t(qc),r&&t(or),r&&t(Kc),r&&t(E),v(so),v(no),v(io),v(ao),v(lo),v(co),r&&t(Rc),r&&t(st),v(uo),r&&t(Qc),r&&t(cr),r&&t(jc),r&&t(k),v(fo),v(go),v(_o),v(vo),r&&t(Wc),r&&t(ot),v(bo),r&&t(Uc),r&&t(mr),r&&t(Bc),v(gr,r),r&&t(Hc),r&&t(te),v(Do),r&&t(Gc),r&&t(nt),v($o),r&&t(zc),r&&t(Fe),r&&t(Yc),r&&t(Y),v(wo),v(To),v(ko),v(Oo),r&&t(Jc),r&&t(it),v(Ao),r&&t(Xc),r&&t(pi),r&&t(Zc),r&&t(J),v(Vo),v(Io),v(Lo),v(qo),r&&t(eu),r&&t(at),v(Ko),r&&t(tu),r&&t(Ro),r&&t(ru),r&&t(y),v(jo),v(Uo),v(Ho),v(Yo),v(Jo),r&&t(su),r&&t(lt),v(Zo),r&&t(ou),r&&t(Te),r&&t(nu),r&&t(X),v(rn),v(on),v(nn)}}}const U5={local:"schedulers",sections:[{local:"what-is-a-scheduler",sections:[{local:"discrete-versus-continuous-schedulers",title:"Discrete versus continuous schedulers"}],title:"What is a scheduler?"},{local:"designing-reusable-schedulers",title:"Designing Re-usable schedulers"},{local:"api",sections:[{local:"diffusers.SchedulerMixin",title:"SchedulerMixin"},{local:"diffusers.schedulers.scheduling_utils.SchedulerOutput",title:"SchedulerOutput"},{local:"implemented-schedulers",sections:[{local:"diffusers.DDIMScheduler",title:"Denoising diffusion implicit models (DDIM)"},{local:"diffusers.DDPMScheduler",title:"Denoising diffusion probabilistic models (DDPM)"},{local:"diffusers.DPMSolverMultistepScheduler",title:"Multistep DPM-Solver"},{local:"diffusers.KarrasVeScheduler",title:"Variance exploding, stochastic sampling from Karras et. al"},{local:"diffusers.LMSDiscreteScheduler",title:"Linear multistep scheduler for discrete beta schedules"},{local:"diffusers.PNDMScheduler",title:"Pseudo numerical methods for diffusion models (PNDM)"},{local:"diffusers.ScoreSdeVeScheduler",title:"variance exploding stochastic differential equation (VE-SDE) scheduler"},{local:"diffusers.IPNDMScheduler",title:"improved pseudo numerical methods for diffusion models (iPNDM)"},{local:"diffusers.schedulers.ScoreSdeVpScheduler",title:"variance preserving stochastic differential equation (VP-SDE) scheduler"},{local:"diffusers.EulerDiscreteScheduler",title:"Euler scheduler"},{local:"diffusers.EulerAncestralDiscreteScheduler",title:"Euler Ancestral scheduler"},{local:"diffusers.VQDiffusionScheduler",title:"VQDiffusionScheduler"},{local:"diffusers.RePaintScheduler",title:"RePaint scheduler"}],title:"Implemented Schedulers"}],title:"API"}],title:"Schedulers"};function B5(tc){return R5(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class J5 extends N5{constructor(Z){super();L5(this,Z,B5,W5,q5,{})}}export{J5 as default,U5 as metadata};
