import{S as zt,i as Kt,s as Qt,e as r,k as l,w as V,t as i,M as Xt,c as s,d as o,m as c,a as n,x as H,h as a,b as d,G as e,g as h,y as J,L as Zt,q as U,o as j,B,v as eo}from"../../../chunks/vendor-hf-doc-builder.js";import{D as Ee}from"../../../chunks/Docstring-hf-doc-builder.js";import{I as yt}from"../../../chunks/IconCopyLink-hf-doc-builder.js";function to(Mt){let _,ue,D,M,ee,E,Pe,te,Te,he,b,w,oe,P,ke,re,Ae,me,T,k,Ce,Fe,ge,G,qe,ve,R,Ne,_e,v,Oe,A,Le,We,C,Ve,He,De,y,S,se,F,Je,ne,Ue,be,p,q,je,ie,Be,Ge,u,Y,Re,Ye,ae,ze,Ke,de,Qe,Xe,le,Ze,et,z,tt,ot,K,rt,st,Q,nt,it,at,X,dt,N,lt,ct,$,O,pt,ce,ft,ut,x,L,ht,pe,mt,gt,I,W,vt,fe,_t,ye;return E=new yt({}),P=new yt({}),F=new yt({}),q=new Ee({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.Union[numpy.ndarray, typing.List[float], NoneType] = None"},{name:"clip_sample",val:": bool = True"},{name:"set_alpha_to_one",val:": bool = True"},{name:"steps_offset",val:": int = 0"},{name:"prediction_type",val:": str = 'epsilon'"},{name:"**kwargs",val:""}],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"},{anchor:"diffusers.DDIMScheduler.prediction_type",description:`<strong>prediction_type</strong> (<code>str</code>, default <code>epsilon</code>, optional) &#x2014;
prediction type of the scheduler function, one of <code>epsilon</code> (predicting the noise of the diffusion
process), <code>sample</code> (directly predicting the noisy sample<code>) or </code>v_prediction\` (see section 2.4
<a href="https://imagen.research.google/video/paper.pdf" rel="nofollow">https://imagen.research.google/video/paper.pdf</a>)`,name:"prediction_type"}],source:"https://github.com/huggingface/diffusers/blob/v0.11.0/src/diffusers/schedulers/scheduling_ddim.py#L78"}}),O=new Ee({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/v0.11.0/src/diffusers/schedulers/scheduling_ddim.py#L172",returnDescription:`
<p>scaled input sample</p>
`,returnType:`
<p><code>torch.FloatTensor</code></p>
`}}),L=new Ee({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/v0.11.0/src/diffusers/schedulers/scheduling_ddim.py#L196"}}),W=new Ee({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/v0.11.0/src/diffusers/schedulers/scheduling_ddim.py#L212",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>
`}}),{c(){_=r("meta"),ue=l(),D=r("h1"),M=r("a"),ee=r("span"),V(E.$$.fragment),Pe=l(),te=r("span"),Te=i("Denoising diffusion implicit models (DDIM)"),he=l(),b=r("h2"),w=r("a"),oe=r("span"),V(P.$$.fragment),ke=l(),re=r("span"),Ae=i("Overview"),me=l(),T=r("p"),k=r("a"),Ce=i("Denoising Diffusion Implicit Models"),Fe=i(" (DDIM) by Jiaming Song, Chenlin Meng and Stefano Ermon."),ge=l(),G=r("p"),qe=i("The abstract of the paper is the following:"),ve=l(),R=r("p"),Ne=i("Denoising diffusion probabilistic models (DDPMs) have achieved high quality image generation without adversarial training, yet they require simulating a Markov chain for many steps to produce a sample. To accelerate sampling, we present denoising diffusion implicit models (DDIMs), a more efficient class of iterative implicit probabilistic models with the same training procedure as DDPMs. In DDPMs, the generative process is defined as the reverse of a Markovian diffusion process. We construct a class of non-Markovian diffusion processes that lead to the same training objective, but whose reverse process can be much faster to sample from. We empirically demonstrate that DDIMs can produce high quality samples 10\xD7 to 50\xD7 faster in terms of wall-clock time compared to DDPMs, allow us to trade off computation for sample quality, and can perform semantically meaningful image interpolation directly in the latent space."),_e=l(),v=r("p"),Oe=i("The original codebase of this paper can be found here: "),A=r("a"),Le=i("ermongroup/ddim"),We=i(`.
For questions, feel free to contact the author on `),C=r("a"),Ve=i("tsong.me"),He=i("."),De=l(),y=r("h2"),S=r("a"),se=r("span"),V(F.$$.fragment),Je=l(),ne=r("span"),Ue=i("DDIMScheduler"),be=l(),p=r("div"),V(q.$$.fragment),je=l(),ie=r("p"),Be=i(`Denoising diffusion implicit models is a scheduler that extends the denoising procedure introduced in denoising
diffusion probabilistic models (DDPMs) with non-Markovian guidance.`),Ge=l(),u=r("p"),Y=r("a"),Re=i("~ConfigMixin"),Ye=i(" takes care of storing all config attributes that are passed in the scheduler\u2019s "),ae=r("code"),ze=i("__init__"),Ke=i(`
function, such as `),de=r("code"),Qe=i("num_train_timesteps"),Xe=i(". They can be accessed via "),le=r("code"),Ze=i("scheduler.config.num_train_timesteps"),et=i(`.
`),z=r("a"),tt=i("SchedulerMixin"),ot=i(" provides general loading and saving functionality via the "),K=r("a"),rt=i("SchedulerMixin.save_pretrained()"),st=i(` and
`),Q=r("a"),nt=i("from_pretrained()"),it=i(" functions."),at=l(),X=r("p"),dt=i("For more details, see the original paper: "),N=r("a"),lt=i("https://arxiv.org/abs/2010.02502"),ct=l(),$=r("div"),V(O.$$.fragment),pt=l(),ce=r("p"),ft=i(`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),ut=l(),x=r("div"),V(L.$$.fragment),ht=l(),pe=r("p"),mt=i("Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference."),gt=l(),I=r("div"),V(W.$$.fragment),vt=l(),fe=r("p"),_t=i(`Predict the sample at the previous timestep by reversing the SDE. Core function to propagate the diffusion
process from the learned model outputs (most often the predicted noise).`),this.h()},l(t){const f=Xt('[data-svelte="svelte-1phssyn"]',document.head);_=s(f,"META",{name:!0,content:!0}),f.forEach(o),ue=c(t),D=s(t,"H1",{class:!0});var Me=n(D);M=s(Me,"A",{id:!0,class:!0,href:!0});var wt=n(M);ee=s(wt,"SPAN",{});var St=n(ee);H(E.$$.fragment,St),St.forEach(o),wt.forEach(o),Pe=c(Me),te=s(Me,"SPAN",{});var $t=n(te);Te=a($t,"Denoising diffusion implicit models (DDIM)"),$t.forEach(o),Me.forEach(o),he=c(t),b=s(t,"H2",{class:!0});var we=n(b);w=s(we,"A",{id:!0,class:!0,href:!0});var xt=n(w);oe=s(xt,"SPAN",{});var It=n(oe);H(P.$$.fragment,It),It.forEach(o),xt.forEach(o),ke=c(we),re=s(we,"SPAN",{});var Et=n(re);Ae=a(Et,"Overview"),Et.forEach(o),we.forEach(o),me=c(t),T=s(t,"P",{});var Dt=n(T);k=s(Dt,"A",{href:!0,rel:!0});var Pt=n(k);Ce=a(Pt,"Denoising Diffusion Implicit Models"),Pt.forEach(o),Fe=a(Dt," (DDIM) by Jiaming Song, Chenlin Meng and Stefano Ermon."),Dt.forEach(o),ge=c(t),G=s(t,"P",{});var Tt=n(G);qe=a(Tt,"The abstract of the paper is the following:"),Tt.forEach(o),ve=c(t),R=s(t,"P",{});var kt=n(R);Ne=a(kt,"Denoising diffusion probabilistic models (DDPMs) have achieved high quality image generation without adversarial training, yet they require simulating a Markov chain for many steps to produce a sample. To accelerate sampling, we present denoising diffusion implicit models (DDIMs), a more efficient class of iterative implicit probabilistic models with the same training procedure as DDPMs. In DDPMs, the generative process is defined as the reverse of a Markovian diffusion process. We construct a class of non-Markovian diffusion processes that lead to the same training objective, but whose reverse process can be much faster to sample from. We empirically demonstrate that DDIMs can produce high quality samples 10\xD7 to 50\xD7 faster in terms of wall-clock time compared to DDPMs, allow us to trade off computation for sample quality, and can perform semantically meaningful image interpolation directly in the latent space."),kt.forEach(o),_e=c(t),v=s(t,"P",{});var Z=n(v);Oe=a(Z,"The original codebase of this paper can be found here: "),A=s(Z,"A",{href:!0,rel:!0});var At=n(A);Le=a(At,"ermongroup/ddim"),At.forEach(o),We=a(Z,`.
For questions, feel free to contact the author on `),C=s(Z,"A",{href:!0,rel:!0});var Ct=n(C);Ve=a(Ct,"tsong.me"),Ct.forEach(o),He=a(Z,"."),Z.forEach(o),De=c(t),y=s(t,"H2",{class:!0});var Se=n(y);S=s(Se,"A",{id:!0,class:!0,href:!0});var Ft=n(S);se=s(Ft,"SPAN",{});var qt=n(se);H(F.$$.fragment,qt),qt.forEach(o),Ft.forEach(o),Je=c(Se),ne=s(Se,"SPAN",{});var Nt=n(ne);Ue=a(Nt,"DDIMScheduler"),Nt.forEach(o),Se.forEach(o),be=c(t),p=s(t,"DIV",{class:!0});var g=n(p);H(q.$$.fragment,g),je=c(g),ie=s(g,"P",{});var Ot=n(ie);Be=a(Ot,`Denoising diffusion implicit models is a scheduler that extends the denoising procedure introduced in denoising
diffusion probabilistic models (DDPMs) with non-Markovian guidance.`),Ot.forEach(o),Ge=c(g),u=s(g,"P",{});var m=n(u);Y=s(m,"A",{href:!0});var Lt=n(Y);Re=a(Lt,"~ConfigMixin"),Lt.forEach(o),Ye=a(m," takes care of storing all config attributes that are passed in the scheduler\u2019s "),ae=s(m,"CODE",{});var Wt=n(ae);ze=a(Wt,"__init__"),Wt.forEach(o),Ke=a(m,`
function, such as `),de=s(m,"CODE",{});var Vt=n(de);Qe=a(Vt,"num_train_timesteps"),Vt.forEach(o),Xe=a(m,". They can be accessed via "),le=s(m,"CODE",{});var Ht=n(le);Ze=a(Ht,"scheduler.config.num_train_timesteps"),Ht.forEach(o),et=a(m,`.
`),z=s(m,"A",{href:!0});var Jt=n(z);tt=a(Jt,"SchedulerMixin"),Jt.forEach(o),ot=a(m," provides general loading and saving functionality via the "),K=s(m,"A",{href:!0});var Ut=n(K);rt=a(Ut,"SchedulerMixin.save_pretrained()"),Ut.forEach(o),st=a(m,` and
`),Q=s(m,"A",{href:!0});var jt=n(Q);nt=a(jt,"from_pretrained()"),jt.forEach(o),it=a(m," functions."),m.forEach(o),at=c(g),X=s(g,"P",{});var bt=n(X);dt=a(bt,"For more details, see the original paper: "),N=s(bt,"A",{href:!0,rel:!0});var Bt=n(N);lt=a(Bt,"https://arxiv.org/abs/2010.02502"),Bt.forEach(o),bt.forEach(o),ct=c(g),$=s(g,"DIV",{class:!0});var $e=n($);H(O.$$.fragment,$e),pt=c($e),ce=s($e,"P",{});var Gt=n(ce);ft=a(Gt,`Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
current timestep.`),Gt.forEach(o),$e.forEach(o),ut=c(g),x=s(g,"DIV",{class:!0});var xe=n(x);H(L.$$.fragment,xe),ht=c(xe),pe=s(xe,"P",{});var Rt=n(pe);mt=a(Rt,"Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference."),Rt.forEach(o),xe.forEach(o),gt=c(g),I=s(g,"DIV",{class:!0});var Ie=n(I);H(W.$$.fragment,Ie),vt=c(Ie),fe=s(Ie,"P",{});var Yt=n(fe);_t=a(Yt,`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).`),Yt.forEach(o),Ie.forEach(o),g.forEach(o),this.h()},h(){d(_,"name","hf:doc:metadata"),d(_,"content",JSON.stringify(oo)),d(M,"id","denoising-diffusion-implicit-models-ddim"),d(M,"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(M,"href","#denoising-diffusion-implicit-models-ddim"),d(D,"class","relative group"),d(w,"id","overview"),d(w,"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(w,"href","#overview"),d(b,"class","relative group"),d(k,"href","https://arxiv.org/abs/2010.02502"),d(k,"rel","nofollow"),d(A,"href","https://github.com/ermongroup/ddim"),d(A,"rel","nofollow"),d(C,"href","https://tsong.me/"),d(C,"rel","nofollow"),d(S,"id","diffusers.DDIMScheduler"),d(S,"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(S,"href","#diffusers.DDIMScheduler"),d(y,"class","relative group"),d(Y,"href","/docs/diffusers/v0.11.0/en/api/configuration#diffusers.ConfigMixin"),d(z,"href","/docs/diffusers/v0.11.0/en/api/schedulers/overview#diffusers.SchedulerMixin"),d(K,"href","/docs/diffusers/v0.11.0/en/api/schedulers/overview#diffusers.SchedulerMixin.save_pretrained"),d(Q,"href","/docs/diffusers/v0.11.0/en/api/schedulers/overview#diffusers.SchedulerMixin.from_pretrained"),d(N,"href","https://arxiv.org/abs/2010.02502"),d(N,"rel","nofollow"),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(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(I,"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")},m(t,f){e(document.head,_),h(t,ue,f),h(t,D,f),e(D,M),e(M,ee),J(E,ee,null),e(D,Pe),e(D,te),e(te,Te),h(t,he,f),h(t,b,f),e(b,w),e(w,oe),J(P,oe,null),e(b,ke),e(b,re),e(re,Ae),h(t,me,f),h(t,T,f),e(T,k),e(k,Ce),e(T,Fe),h(t,ge,f),h(t,G,f),e(G,qe),h(t,ve,f),h(t,R,f),e(R,Ne),h(t,_e,f),h(t,v,f),e(v,Oe),e(v,A),e(A,Le),e(v,We),e(v,C),e(C,Ve),e(v,He),h(t,De,f),h(t,y,f),e(y,S),e(S,se),J(F,se,null),e(y,Je),e(y,ne),e(ne,Ue),h(t,be,f),h(t,p,f),J(q,p,null),e(p,je),e(p,ie),e(ie,Be),e(p,Ge),e(p,u),e(u,Y),e(Y,Re),e(u,Ye),e(u,ae),e(ae,ze),e(u,Ke),e(u,de),e(de,Qe),e(u,Xe),e(u,le),e(le,Ze),e(u,et),e(u,z),e(z,tt),e(u,ot),e(u,K),e(K,rt),e(u,st),e(u,Q),e(Q,nt),e(u,it),e(p,at),e(p,X),e(X,dt),e(X,N),e(N,lt),e(p,ct),e(p,$),J(O,$,null),e($,pt),e($,ce),e(ce,ft),e(p,ut),e(p,x),J(L,x,null),e(x,ht),e(x,pe),e(pe,mt),e(p,gt),e(p,I),J(W,I,null),e(I,vt),e(I,fe),e(fe,_t),ye=!0},p:Zt,i(t){ye||(U(E.$$.fragment,t),U(P.$$.fragment,t),U(F.$$.fragment,t),U(q.$$.fragment,t),U(O.$$.fragment,t),U(L.$$.fragment,t),U(W.$$.fragment,t),ye=!0)},o(t){j(E.$$.fragment,t),j(P.$$.fragment,t),j(F.$$.fragment,t),j(q.$$.fragment,t),j(O.$$.fragment,t),j(L.$$.fragment,t),j(W.$$.fragment,t),ye=!1},d(t){o(_),t&&o(ue),t&&o(D),B(E),t&&o(he),t&&o(b),B(P),t&&o(me),t&&o(T),t&&o(ge),t&&o(G),t&&o(ve),t&&o(R),t&&o(_e),t&&o(v),t&&o(De),t&&o(y),B(F),t&&o(be),t&&o(p),B(q),B(O),B(L),B(W)}}}const oo={local:"denoising-diffusion-implicit-models-ddim",sections:[{local:"overview",title:"Overview"},{local:"diffusers.DDIMScheduler",title:"DDIMScheduler"}],title:"Denoising diffusion implicit models (DDIM)"};function ro(Mt){return eo(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class ao extends zt{constructor(_){super();Kt(this,_,ro,to,Qt,{})}}export{ao as default,oo as metadata};
