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