import{s as Re,o as qe,n as We}from"../chunks/scheduler.8c3d61f6.js";import{S as ze,i as Ye,g as i,s as a,r as m,A as He,h as l,f as n,c as s,j as K,u,x as w,k as ee,y as T,a as o,v as f,d as g,t as h,w as _}from"../chunks/index.da70eac4.js";import{T as Ve}from"../chunks/Tip.1d9b8c37.js";import{D as Ze}from"../chunks/Docstring.c021b19a.js";import{C as Me}from"../chunks/CodeBlock.a9c4becf.js";import{E as Le}from"../chunks/ExampleCodeBlock.56b4589c.js";import{H as Te,E as Se}from"../chunks/getInferenceSnippets.725ed3d4.js";function De(V){let r,U='AuraFlow can be quite expensive to run on consumer hardware devices. However, you can perform a suite of optimizations to run it faster and in a more memory-friendly manner. Check out <a href="https://huggingface.co/blog/sd3#memory-optimizations-for-sd3" rel="nofollow">this section</a> for more details.';return{c(){r=i("p"),r.innerHTML=U},l(c){r=l(c,"P",{"data-svelte-h":!0}),w(r)!=="svelte-q1wg22"&&(r.innerHTML=U)},m(c,d){o(c,r,d)},p:We,d(c){c&&n(r)}}}function Oe(V){let r,U="Examples:",c,d,b;return d=new Me({props:{code:"aW1wb3J0JTIwdG9yY2glMEFmcm9tJTIwZGlmZnVzZXJzJTIwaW1wb3J0JTIwQXVyYUZsb3dQaXBlbGluZSUwQSUwQXBpcGUlMjAlM0QlMjBBdXJhRmxvd1BpcGVsaW5lLmZyb21fcHJldHJhaW5lZCglMjJmYWwlMkZBdXJhRmxvdyUyMiUyQyUyMHRvcmNoX2R0eXBlJTNEdG9yY2guZmxvYXQxNiklMEFwaXBlJTIwJTNEJTIwcGlwZS50byglMjJjdWRhJTIyKSUwQXByb21wdCUyMCUzRCUyMCUyMkElMjBjYXQlMjBob2xkaW5nJTIwYSUyMHNpZ24lMjB0aGF0JTIwc2F5cyUyMGhlbGxvJTIwd29ybGQlMjIlMEFpbWFnZSUyMCUzRCUyMHBpcGUocHJvbXB0KS5pbWFnZXMlNUIwJTVEJTBBaW1hZ2Uuc2F2ZSglMjJhdXJhX2Zsb3cucG5nJTIyKQ==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> torch
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> diffusers <span class="hljs-keyword">import</span> AuraFlowPipeline

<span class="hljs-meta">&gt;&gt;&gt; </span>pipe = AuraFlowPipeline.from_pretrained(<span class="hljs-string">&quot;fal/AuraFlow&quot;</span>, torch_dtype=torch.float16)
<span class="hljs-meta">&gt;&gt;&gt; </span>pipe = pipe.to(<span class="hljs-string">&quot;cuda&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>prompt = <span class="hljs-string">&quot;A cat holding a sign that says hello world&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>image = pipe(prompt).images[<span class="hljs-number">0</span>]
<span class="hljs-meta">&gt;&gt;&gt; </span>image.save(<span class="hljs-string">&quot;aura_flow.png&quot;</span>)`,wrap:!1}}),{c(){r=i("p"),r.textContent=U,c=a(),m(d.$$.fragment)},l(p){r=l(p,"P",{"data-svelte-h":!0}),w(r)!=="svelte-kvfsh7"&&(r.textContent=U),c=s(p),u(d.$$.fragment,p)},m(p,M){o(p,r,M),o(p,c,M),f(d,p,M),b=!0},p:We,i(p){b||(g(d.$$.fragment,p),b=!0)},o(p){h(d.$$.fragment,p),b=!1},d(p){p&&(n(r),n(c)),_(d,p)}}}function Ke(V){let r,U,c,d,b,p,M,$e='AuraFlow is inspired by <a href="../pipelines/stable_diffusion/stable_diffusion_3">Stable Diffusion 3</a> and is by far the largest text-to-image generation model that comes with an Apache 2.0 license. This model achieves state-of-the-art results on the <a href="https://github.com/djghosh13/geneval" rel="nofollow">GenEval</a> benchmark.',te,$,Ae='It was developed by the Fal team and more details about it can be found in <a href="https://blog.fal.ai/auraflow/" rel="nofollow">this blog post</a>.',ne,x,oe,A,ae,C,Ce="Quantization helps reduce the memory requirements of very large models by storing model weights in a lower precision data type. However, quantization may have varying impact on video quality depending on the video model.",se,I,Ie='Refer to the <a href="../../quantization/overview">Quantization</a> overview to learn more about supported quantization backends and selecting a quantization backend that supports your use case. The example below demonstrates how to load a quantized <a href="/docs/diffusers/main/en/api/pipelines/aura_flow#diffusers.AuraFlowPipeline">AuraFlowPipeline</a> for inference with bitsandbytes.',re,j,ie,B,je='Loading <a href="https://huggingface.co/docs/diffusers/quantization/gguf" rel="nofollow">GGUF checkpoints</a> are also supported:',le,G,pe,P,ce,X,Be='AuraFlow can be compiled with <code>torch.compile()</code> to speed up inference latency even for different resolutions. First, install PyTorch nightly following the instructions from <a href="https://pytorch.org/" rel="nofollow">here</a>. The snippet below shows the changes needed to enable this:',de,E,me,N,Ge='Specifying <code>use_duck_shape</code> to be <code>False</code> instructs the compiler if it should use the same symbolic variable to represent input sizes that are the same. For more details, check out <a href="https://github.com/huggingface/diffusers/pull/11327#discussion_r2047659790" rel="nofollow">this comment</a>.',ue,Q,Pe="This enables from 100% (on low resolutions) to a 30% (on 1536x1536 resolution) speed improvements.",fe,W,Xe='Thanks to <a href="https://github.com/huggingface/diffusers/pull/11297/" rel="nofollow">AstraliteHeart</a> who helped us rewrite the <a href="/docs/diffusers/main/en/api/models/aura_flow_transformer2d#diffusers.AuraFlowTransformer2DModel">AuraFlowTransformer2DModel</a> class so that the above works for different resolutions (<a href="https://github.com/huggingface/diffusers/pull/11297/" rel="nofollow">PR</a>).',ge,R,he,J,q,Je,y,z,ve,L,Ee="Function invoked when calling the pipeline for generation.",Ue,k,Fe,S,Ne=`Returns: <a href="/docs/diffusers/main/en/api/pipelines/unclip#diffusers.ImagePipelineOutput">ImagePipelineOutput</a> or <code>tuple</code>:
If <code>return_dict</code> is <code>True</code>, <a href="/docs/diffusers/main/en/api/pipelines/unclip#diffusers.ImagePipelineOutput">ImagePipelineOutput</a> is returned, otherwise a <code>tuple</code> is returned
where the first element is a list with the generated images.`,xe,Z,Y,ke,D,Qe="Encodes the prompt into text encoder hidden states.",_e,H,we,O,be;return b=new Te({props:{title:"AuraFlow",local:"auraflow",headingTag:"h1"}}),x=new Ve({props:{$$slots:{default:[De]},$$scope:{ctx:V}}}),A=new Te({props:{title:"Quantization",local:"quantization",headingTag:"h2"}}),j=new Me({props:{code:"aW1wb3J0JTIwdG9yY2glMEFmcm9tJTIwZGlmZnVzZXJzJTIwaW1wb3J0JTIwQml0c0FuZEJ5dGVzQ29uZmlnJTIwYXMlMjBEaWZmdXNlcnNCaXRzQW5kQnl0ZXNDb25maWclMkMlMjBBdXJhRmxvd1RyYW5zZm9ybWVyMkRNb2RlbCUyQyUyMEF1cmFGbG93UGlwZWxpbmUlMEFmcm9tJTIwdHJhbnNmb3JtZXJzJTIwaW1wb3J0JTIwQml0c0FuZEJ5dGVzQ29uZmlnJTIwYXMlMjBCaXRzQW5kQnl0ZXNDb25maWclMkMlMjBUNUVuY29kZXJNb2RlbCUwQSUwQXF1YW50X2NvbmZpZyUyMCUzRCUyMEJpdHNBbmRCeXRlc0NvbmZpZyhsb2FkX2luXzhiaXQlM0RUcnVlKSUwQXRleHRfZW5jb2Rlcl84Yml0JTIwJTNEJTIwVDVFbmNvZGVyTW9kZWwuZnJvbV9wcmV0cmFpbmVkKCUwQSUyMCUyMCUyMCUyMCUyMmZhbCUyRkF1cmFGbG93JTIyJTJDJTBBJTIwJTIwJTIwJTIwc3ViZm9sZGVyJTNEJTIydGV4dF9lbmNvZGVyJTIyJTJDJTBBJTIwJTIwJTIwJTIwcXVhbnRpemF0aW9uX2NvbmZpZyUzRHF1YW50X2NvbmZpZyUyQyUwQSUyMCUyMCUyMCUyMHRvcmNoX2R0eXBlJTNEdG9yY2guZmxvYXQxNiUyQyUwQSklMEElMEFxdWFudF9jb25maWclMjAlM0QlMjBEaWZmdXNlcnNCaXRzQW5kQnl0ZXNDb25maWcobG9hZF9pbl84Yml0JTNEVHJ1ZSklMEF0cmFuc2Zvcm1lcl84Yml0JTIwJTNEJTIwQXVyYUZsb3dUcmFuc2Zvcm1lcjJETW9kZWwuZnJvbV9wcmV0cmFpbmVkKCUwQSUyMCUyMCUyMCUyMCUyMmZhbCUyRkF1cmFGbG93JTIyJTJDJTBBJTIwJTIwJTIwJTIwc3ViZm9sZGVyJTNEJTIydHJhbnNmb3JtZXIlMjIlMkMlMEElMjAlMjAlMjAlMjBxdWFudGl6YXRpb25fY29uZmlnJTNEcXVhbnRfY29uZmlnJTJDJTBBJTIwJTIwJTIwJTIwdG9yY2hfZHR5cGUlM0R0b3JjaC5mbG9hdDE2JTJDJTBBKSUwQSUwQXBpcGVsaW5lJTIwJTNEJTIwQXVyYUZsb3dQaXBlbGluZS5mcm9tX3ByZXRyYWluZWQoJTBBJTIwJTIwJTIwJTIwJTIyZmFsJTJGQXVyYUZsb3clMjIlMkMlMEElMjAlMjAlMjAlMjB0ZXh0X2VuY29kZXIlM0R0ZXh0X2VuY29kZXJfOGJpdCUyQyUwQSUyMCUyMCUyMCUyMHRyYW5zZm9ybWVyJTNEdHJhbnNmb3JtZXJfOGJpdCUyQyUwQSUyMCUyMCUyMCUyMHRvcmNoX2R0eXBlJTNEdG9yY2guZmxvYXQxNiUyQyUwQSUyMCUyMCUyMCUyMGRldmljZV9tYXAlM0QlMjJiYWxhbmNlZCUyMiUyQyUwQSklMEElMEFwcm9tcHQlMjAlM0QlMjAlMjJhJTIwdGlueSUyMGFzdHJvbmF1dCUyMGhhdGNoaW5nJTIwZnJvbSUyMGFuJTIwZWdnJTIwb24lMjB0aGUlMjBtb29uJTIyJTBBaW1hZ2UlMjAlM0QlMjBwaXBlbGluZShwcm9tcHQpLmltYWdlcyU1QjAlNUQlMEFpbWFnZS5zYXZlKCUyMmF1cmFmbG93LnBuZyUyMik=",highlighted:`<span class="hljs-keyword">import</span> torch
<span class="hljs-keyword">from</span> diffusers <span class="hljs-keyword">import</span> BitsAndBytesConfig <span class="hljs-keyword">as</span> DiffusersBitsAndBytesConfig, AuraFlowTransformer2DModel, AuraFlowPipeline
<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> BitsAndBytesConfig <span class="hljs-keyword">as</span> BitsAndBytesConfig, T5EncoderModel

quant_config = BitsAndBytesConfig(load_in_8bit=<span class="hljs-literal">True</span>)
text_encoder_8bit = T5EncoderModel.from_pretrained(
    <span class="hljs-string">&quot;fal/AuraFlow&quot;</span>,
    subfolder=<span class="hljs-string">&quot;text_encoder&quot;</span>,
    quantization_config=quant_config,
    torch_dtype=torch.float16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=<span class="hljs-literal">True</span>)
transformer_8bit = AuraFlowTransformer2DModel.from_pretrained(
    <span class="hljs-string">&quot;fal/AuraFlow&quot;</span>,
    subfolder=<span class="hljs-string">&quot;transformer&quot;</span>,
    quantization_config=quant_config,
    torch_dtype=torch.float16,
)

pipeline = AuraFlowPipeline.from_pretrained(
    <span class="hljs-string">&quot;fal/AuraFlow&quot;</span>,
    text_encoder=text_encoder_8bit,
    transformer=transformer_8bit,
    torch_dtype=torch.float16,
    device_map=<span class="hljs-string">&quot;balanced&quot;</span>,
)

prompt = <span class="hljs-string">&quot;a tiny astronaut hatching from an egg on the moon&quot;</span>
image = pipeline(prompt).images[<span class="hljs-number">0</span>]
image.save(<span class="hljs-string">&quot;auraflow.png&quot;</span>)`,wrap:!1}}),G=new Me({props:{code:"aW1wb3J0JTIwdG9yY2glMEFmcm9tJTIwZGlmZnVzZXJzJTIwaW1wb3J0JTIwKCUwQSUyMCUyMCUyMCUyMEF1cmFGbG93UGlwZWxpbmUlMkMlMEElMjAlMjAlMjAlMjBHR1VGUXVhbnRpemF0aW9uQ29uZmlnJTJDJTBBJTIwJTIwJTIwJTIwQXVyYUZsb3dUcmFuc2Zvcm1lcjJETW9kZWwlMkMlMEEpJTBBJTBBdHJhbnNmb3JtZXIlMjAlM0QlMjBBdXJhRmxvd1RyYW5zZm9ybWVyMkRNb2RlbC5mcm9tX3NpbmdsZV9maWxlKCUwQSUyMCUyMCUyMCUyMCUyMmh0dHBzJTNBJTJGJTJGaHVnZ2luZ2ZhY2UuY28lMkZjaXR5OTYlMkZBdXJhRmxvdy12MC4zLWdndWYlMkZibG9iJTJGbWFpbiUyRmF1cmFfZmxvd18wLjMtUTJfSy5nZ3VmJTIyJTJDJTBBJTIwJTIwJTIwJTIwcXVhbnRpemF0aW9uX2NvbmZpZyUzREdHVUZRdWFudGl6YXRpb25Db25maWcoY29tcHV0ZV9kdHlwZSUzRHRvcmNoLmJmbG9hdDE2KSUyQyUwQSUyMCUyMCUyMCUyMHRvcmNoX2R0eXBlJTNEdG9yY2guYmZsb2F0MTYlMkMlMEEpJTBBJTBBcGlwZWxpbmUlMjAlM0QlMjBBdXJhRmxvd1BpcGVsaW5lLmZyb21fcHJldHJhaW5lZCglMEElMjAlMjAlMjAlMjAlMjJmYWwlMkZBdXJhRmxvdy12MC4zJTIyJTJDJTBBJTIwJTIwJTIwJTIwdHJhbnNmb3JtZXIlM0R0cmFuc2Zvcm1lciUyQyUwQSUyMCUyMCUyMCUyMHRvcmNoX2R0eXBlJTNEdG9yY2guYmZsb2F0MTYlMkMlMEEpJTBBJTBBcHJvbXB0JTIwJTNEJTIwJTIyYSUyMGN1dGUlMjBwb255JTIwaW4lMjBhJTIwZmllbGQlMjBvZiUyMGZsb3dlcnMlMjIlMEFpbWFnZSUyMCUzRCUyMHBpcGVsaW5lKHByb21wdCkuaW1hZ2VzJTVCMCU1RCUwQWltYWdlLnNhdmUoJTIyYXVyYWZsb3cucG5nJTIyKQ==",highlighted:`<span class="hljs-keyword">import</span> torch
<span class="hljs-keyword">from</span> diffusers <span class="hljs-keyword">import</span> (
    AuraFlowPipeline,
    GGUFQuantizationConfig,
    AuraFlowTransformer2DModel,
)

transformer = AuraFlowTransformer2DModel.from_single_file(
    <span class="hljs-string">&quot;https://huggingface.co/city96/AuraFlow-v0.3-gguf/blob/main/aura_flow_0.3-Q2_K.gguf&quot;</span>,
    quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
    torch_dtype=torch.bfloat16,
)

pipeline = AuraFlowPipeline.from_pretrained(
    <span class="hljs-string">&quot;fal/AuraFlow-v0.3&quot;</span>,
    transformer=transformer,
    torch_dtype=torch.bfloat16,
)

prompt = <span class="hljs-string">&quot;a cute pony in a field of flowers&quot;</span>
image = pipeline(prompt).images[<span class="hljs-number">0</span>]
image.save(<span class="hljs-string">&quot;auraflow.png&quot;</span>)`,wrap:!1}}),P=new Te({props:{title:"Support for torch.compile()",local:"support-for-torchcompile",headingTag:"h2"}}),E=new Me({props:{code:"JTJCJTIwdG9yY2guZnguZXhwZXJpbWVudGFsLl9jb25maWcudXNlX2R1Y2tfc2hhcGUlMjAlM0QlMjBGYWxzZSUwQSUyQiUyMHBpcGVsaW5lLnRyYW5zZm9ybWVyJTIwJTNEJTIwdG9yY2guY29tcGlsZSglMEElMjAlMjAlMjAlMjBwaXBlbGluZS50cmFuc2Zvcm1lciUyQyUyMGZ1bGxncmFwaCUzRFRydWUlMkMlMjBkeW5hbWljJTNEVHJ1ZSUwQSk=",highlighted:`<span class="hljs-addition">+ torch.fx.experimental._config.use_duck_shape = False</span>
<span class="hljs-addition">+ pipeline.transformer = torch.compile(</span>
    pipeline.transformer, fullgraph=True, dynamic=True
)`,wrap:!1}}),R=new Te({props:{title:"AuraFlowPipeline",local:"diffusers.AuraFlowPipeline",headingTag:"h2"}}),q=new Ze({props:{name:"class diffusers.AuraFlowPipeline",anchor:"diffusers.AuraFlowPipeline",parameters:[{name:"tokenizer",val:": T5Tokenizer"},{name:"text_encoder",val:": UMT5EncoderModel"},{name:"vae",val:": AutoencoderKL"},{name:"transformer",val:": AuraFlowTransformer2DModel"},{name:"scheduler",val:": FlowMatchEulerDiscreteScheduler"}],parametersDescription:[{anchor:"diffusers.AuraFlowPipeline.tokenizer",description:`<strong>tokenizer</strong> (<code>T5TokenizerFast</code>) &#x2014;
Tokenizer of class
<a href="https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer" rel="nofollow">T5Tokenizer</a>.`,name:"tokenizer"},{anchor:"diffusers.AuraFlowPipeline.text_encoder",description:`<strong>text_encoder</strong> (<code>T5EncoderModel</code>) &#x2014;
Frozen text-encoder. AuraFlow uses
<a href="https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel" rel="nofollow">T5</a>, specifically the
<a href="https://huggingface.co/EleutherAI/pile-t5-xl" rel="nofollow">EleutherAI/pile-t5-xl</a> variant.`,name:"text_encoder"},{anchor:"diffusers.AuraFlowPipeline.vae",description:`<strong>vae</strong> (<a href="/docs/diffusers/main/en/api/models/autoencoderkl#diffusers.AutoencoderKL">AutoencoderKL</a>) &#x2014;
Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.`,name:"vae"},{anchor:"diffusers.AuraFlowPipeline.transformer",description:`<strong>transformer</strong> (<a href="/docs/diffusers/main/en/api/models/aura_flow_transformer2d#diffusers.AuraFlowTransformer2DModel">AuraFlowTransformer2DModel</a>) &#x2014;
Conditional Transformer (MMDiT and DiT) architecture to denoise the encoded image latents.`,name:"transformer"},{anchor:"diffusers.AuraFlowPipeline.scheduler",description:`<strong>scheduler</strong> (<a href="/docs/diffusers/main/en/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler">FlowMatchEulerDiscreteScheduler</a>) &#x2014;
A scheduler to be used in combination with <code>transformer</code> to denoise the encoded image latents.`,name:"scheduler"}],source:"https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/aura_flow/pipeline_aura_flow.py#L123"}}),z=new Ze({props:{name:"__call__",anchor:"diffusers.AuraFlowPipeline.__call__",parameters:[{name:"prompt",val:": typing.Union[str, typing.List[str]] = None"},{name:"negative_prompt",val:": typing.Union[str, typing.List[str]] = None"},{name:"num_inference_steps",val:": int = 50"},{name:"sigmas",val:": typing.List[float] = None"},{name:"guidance_scale",val:": float = 3.5"},{name:"num_images_per_prompt",val:": typing.Optional[int] = 1"},{name:"height",val:": typing.Optional[int] = 1024"},{name:"width",val:": typing.Optional[int] = 1024"},{name:"generator",val:": typing.Union[torch._C.Generator, typing.List[torch._C.Generator], NoneType] = None"},{name:"latents",val:": typing.Optional[torch.Tensor] = None"},{name:"prompt_embeds",val:": typing.Optional[torch.Tensor] = None"},{name:"prompt_attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"negative_prompt_embeds",val:": typing.Optional[torch.Tensor] = None"},{name:"negative_prompt_attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"max_sequence_length",val:": int = 256"},{name:"output_type",val:": typing.Optional[str] = 'pil'"},{name:"return_dict",val:": bool = True"},{name:"attention_kwargs",val:": typing.Optional[typing.Dict[str, typing.Any]] = None"},{name:"callback_on_step_end",val:": typing.Union[typing.Callable[[int, int, typing.Dict], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None"},{name:"callback_on_step_end_tensor_inputs",val:": typing.List[str] = ['latents']"}],parametersDescription:[{anchor:"diffusers.AuraFlowPipeline.__call__.prompt",description:`<strong>prompt</strong> (<code>str</code> or <code>List[str]</code>, <em>optional</em>) &#x2014;
The prompt or prompts to guide the image generation. If not defined, one has to pass <code>prompt_embeds</code>.
instead.`,name:"prompt"},{anchor:"diffusers.AuraFlowPipeline.__call__.negative_prompt",description:`<strong>negative_prompt</strong> (<code>str</code> or <code>List[str]</code>, <em>optional</em>) &#x2014;
The prompt or prompts not to guide the image generation. If not defined, one has to pass
<code>negative_prompt_embeds</code> instead. Ignored when not using guidance (i.e., ignored if <code>guidance_scale</code> is
less than <code>1</code>).`,name:"negative_prompt"},{anchor:"diffusers.AuraFlowPipeline.__call__.height",description:`<strong>height</strong> (<code>int</code>, <em>optional</em>, defaults to self.transformer.config.sample_size * self.vae_scale_factor) &#x2014;
The height in pixels of the generated image. This is set to 1024 by default for best results.`,name:"height"},{anchor:"diffusers.AuraFlowPipeline.__call__.width",description:`<strong>width</strong> (<code>int</code>, <em>optional</em>, defaults to self.transformer.config.sample_size * self.vae_scale_factor) &#x2014;
The width in pixels of the generated image. This is set to 1024 by default for best results.`,name:"width"},{anchor:"diffusers.AuraFlowPipeline.__call__.num_inference_steps",description:`<strong>num_inference_steps</strong> (<code>int</code>, <em>optional</em>, defaults to 50) &#x2014;
The number of denoising steps. More denoising steps usually lead to a higher quality image at the
expense of slower inference.`,name:"num_inference_steps"},{anchor:"diffusers.AuraFlowPipeline.__call__.sigmas",description:`<strong>sigmas</strong> (<code>List[float]</code>, <em>optional</em>) &#x2014;
Custom sigmas used to override the timestep spacing strategy of the scheduler. If <code>sigmas</code> is passed,
<code>num_inference_steps</code> and <code>timesteps</code> must be <code>None</code>.`,name:"sigmas"},{anchor:"diffusers.AuraFlowPipeline.__call__.guidance_scale",description:`<strong>guidance_scale</strong> (<code>float</code>, <em>optional</em>, defaults to 5.0) &#x2014;
Guidance scale as defined in <a href="https://huggingface.co/papers/2207.12598" rel="nofollow">Classifier-Free Diffusion
Guidance</a>. <code>guidance_scale</code> is defined as <code>w</code> of equation 2.
of <a href="https://huggingface.co/papers/2205.11487" rel="nofollow">Imagen Paper</a>. Guidance scale is enabled by setting
<code>guidance_scale &gt; 1</code>. Higher guidance scale encourages to generate images that are closely linked to
the text <code>prompt</code>, usually at the expense of lower image quality.`,name:"guidance_scale"},{anchor:"diffusers.AuraFlowPipeline.__call__.num_images_per_prompt",description:`<strong>num_images_per_prompt</strong> (<code>int</code>, <em>optional</em>, defaults to 1) &#x2014;
The number of images to generate per prompt.`,name:"num_images_per_prompt"},{anchor:"diffusers.AuraFlowPipeline.__call__.generator",description:`<strong>generator</strong> (<code>torch.Generator</code> or <code>List[torch.Generator]</code>, <em>optional</em>) &#x2014;
One or a list of <a href="https://pytorch.org/docs/stable/generated/torch.Generator.html" rel="nofollow">torch generator(s)</a>
to make generation deterministic.`,name:"generator"},{anchor:"diffusers.AuraFlowPipeline.__call__.latents",description:`<strong>latents</strong> (<code>torch.FloatTensor</code>, <em>optional</em>) &#x2014;
Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image
generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
tensor will ge generated by sampling using the supplied random <code>generator</code>.`,name:"latents"},{anchor:"diffusers.AuraFlowPipeline.__call__.prompt_embeds",description:`<strong>prompt_embeds</strong> (<code>torch.FloatTensor</code>, <em>optional</em>) &#x2014;
Pre-generated text embeddings. Can be used to easily tweak text inputs, <em>e.g.</em> prompt weighting. If not
provided, text embeddings will be generated from <code>prompt</code> input argument.`,name:"prompt_embeds"},{anchor:"diffusers.AuraFlowPipeline.__call__.prompt_attention_mask",description:`<strong>prompt_attention_mask</strong> (<code>torch.Tensor</code>, <em>optional</em>) &#x2014;
Pre-generated attention mask for text embeddings.`,name:"prompt_attention_mask"},{anchor:"diffusers.AuraFlowPipeline.__call__.negative_prompt_embeds",description:`<strong>negative_prompt_embeds</strong> (<code>torch.FloatTensor</code>, <em>optional</em>) &#x2014;
Pre-generated negative text embeddings. Can be used to easily tweak text inputs, <em>e.g.</em> prompt
weighting. If not provided, negative_prompt_embeds will be generated from <code>negative_prompt</code> input
argument.`,name:"negative_prompt_embeds"},{anchor:"diffusers.AuraFlowPipeline.__call__.negative_prompt_attention_mask",description:`<strong>negative_prompt_attention_mask</strong> (<code>torch.Tensor</code>, <em>optional</em>) &#x2014;
Pre-generated attention mask for negative text embeddings.`,name:"negative_prompt_attention_mask"},{anchor:"diffusers.AuraFlowPipeline.__call__.output_type",description:`<strong>output_type</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;pil&quot;</code>) &#x2014;
The output format of the generate image. Choose between
<a href="https://pillow.readthedocs.io/en/stable/" rel="nofollow">PIL</a>: <code>PIL.Image.Image</code> or <code>np.array</code>.`,name:"output_type"},{anchor:"diffusers.AuraFlowPipeline.__call__.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not to return a <code>~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput</code> instead
of a plain tuple.`,name:"return_dict"},{anchor:"diffusers.AuraFlowPipeline.__call__.attention_kwargs",description:`<strong>attention_kwargs</strong> (<code>dict</code>, <em>optional</em>) &#x2014;
A kwargs dictionary that if specified is passed along to the <code>AttentionProcessor</code> as defined under
<code>self.processor</code> in
<a href="https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py" rel="nofollow">diffusers.models.attention_processor</a>.`,name:"attention_kwargs"},{anchor:"diffusers.AuraFlowPipeline.__call__.callback_on_step_end",description:`<strong>callback_on_step_end</strong> (<code>Callable</code>, <em>optional</em>) &#x2014;
A function that calls at the end of each denoising steps during the inference. The function is called
with the following arguments: <code>callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)</code>. <code>callback_kwargs</code> will include a list of all tensors as specified by
<code>callback_on_step_end_tensor_inputs</code>.`,name:"callback_on_step_end"},{anchor:"diffusers.AuraFlowPipeline.__call__.callback_on_step_end_tensor_inputs",description:`<strong>callback_on_step_end_tensor_inputs</strong> (<code>List</code>, <em>optional</em>) &#x2014;
The list of tensor inputs for the <code>callback_on_step_end</code> function. The tensors specified in the list
will be passed as <code>callback_kwargs</code> argument. You will only be able to include variables listed in the
<code>._callback_tensor_inputs</code> attribute of your pipeline class.`,name:"callback_on_step_end_tensor_inputs"},{anchor:"diffusers.AuraFlowPipeline.__call__.max_sequence_length",description:"<strong>max_sequence_length</strong> (<code>int</code> defaults to 256) &#x2014; Maximum sequence length to use with the <code>prompt</code>.",name:"max_sequence_length"}],source:"https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/aura_flow/pipeline_aura_flow.py#L438"}}),k=new Le({props:{anchor:"diffusers.AuraFlowPipeline.__call__.example",$$slots:{default:[Oe]},$$scope:{ctx:V}}}),Y=new Ze({props:{name:"encode_prompt",anchor:"diffusers.AuraFlowPipeline.encode_prompt",parameters:[{name:"prompt",val:": typing.Union[str, typing.List[str]]"},{name:"negative_prompt",val:": typing.Union[str, typing.List[str]] = None"},{name:"do_classifier_free_guidance",val:": bool = True"},{name:"num_images_per_prompt",val:": int = 1"},{name:"device",val:": typing.Optional[torch.device] = None"},{name:"prompt_embeds",val:": typing.Optional[torch.Tensor] = None"},{name:"negative_prompt_embeds",val:": typing.Optional[torch.Tensor] = None"},{name:"prompt_attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"negative_prompt_attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"max_sequence_length",val:": int = 256"},{name:"lora_scale",val:": typing.Optional[float] = None"}],parametersDescription:[{anchor:"diffusers.AuraFlowPipeline.encode_prompt.prompt",description:`<strong>prompt</strong> (<code>str</code> or <code>List[str]</code>, <em>optional</em>) &#x2014;
prompt to be encoded`,name:"prompt"},{anchor:"diffusers.AuraFlowPipeline.encode_prompt.negative_prompt",description:`<strong>negative_prompt</strong> (<code>str</code> or <code>List[str]</code>, <em>optional</em>) &#x2014;
The prompt not to guide the image generation. If not defined, one has to pass <code>negative_prompt_embeds</code>
instead. Ignored when not using guidance (i.e., ignored if <code>guidance_scale</code> is less than <code>1</code>).`,name:"negative_prompt"},{anchor:"diffusers.AuraFlowPipeline.encode_prompt.do_classifier_free_guidance",description:`<strong>do_classifier_free_guidance</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
whether to use classifier free guidance or not`,name:"do_classifier_free_guidance"},{anchor:"diffusers.AuraFlowPipeline.encode_prompt.num_images_per_prompt",description:`<strong>num_images_per_prompt</strong> (<code>int</code>, <em>optional</em>, defaults to 1) &#x2014;
number of images that should be generated per prompt`,name:"num_images_per_prompt"},{anchor:"diffusers.AuraFlowPipeline.encode_prompt.device",description:`<strong>device</strong> &#x2014; (<code>torch.device</code>, <em>optional</em>):
torch device to place the resulting embeddings on`,name:"device"},{anchor:"diffusers.AuraFlowPipeline.encode_prompt.prompt_embeds",description:`<strong>prompt_embeds</strong> (<code>torch.Tensor</code>, <em>optional</em>) &#x2014;
Pre-generated text embeddings. Can be used to easily tweak text inputs, <em>e.g.</em> prompt weighting. If not
provided, text embeddings will be generated from <code>prompt</code> input argument.`,name:"prompt_embeds"},{anchor:"diffusers.AuraFlowPipeline.encode_prompt.prompt_attention_mask",description:`<strong>prompt_attention_mask</strong> (<code>torch.Tensor</code>, <em>optional</em>) &#x2014;
Pre-generated attention mask for text embeddings.`,name:"prompt_attention_mask"},{anchor:"diffusers.AuraFlowPipeline.encode_prompt.negative_prompt_embeds",description:`<strong>negative_prompt_embeds</strong> (<code>torch.Tensor</code>, <em>optional</em>) &#x2014;
Pre-generated negative text embeddings.`,name:"negative_prompt_embeds"},{anchor:"diffusers.AuraFlowPipeline.encode_prompt.negative_prompt_attention_mask",description:`<strong>negative_prompt_attention_mask</strong> (<code>torch.Tensor</code>, <em>optional</em>) &#x2014;
Pre-generated attention mask for negative text embeddings.`,name:"negative_prompt_attention_mask"},{anchor:"diffusers.AuraFlowPipeline.encode_prompt.max_sequence_length",description:"<strong>max_sequence_length</strong> (<code>int</code>, defaults to 256) &#x2014; Maximum sequence length to use for the prompt.",name:"max_sequence_length"},{anchor:"diffusers.AuraFlowPipeline.encode_prompt.lora_scale",description:`<strong>lora_scale</strong> (<code>float</code>, <em>optional</em>) &#x2014;
A lora scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.`,name:"lora_scale"}],source:"https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/aura_flow/pipeline_aura_flow.py#L232"}}),H=new Se({props:{source:"https://github.com/huggingface/diffusers/blob/main/docs/source/en/api/pipelines/aura_flow.md"}}),{c(){r=i("meta"),U=a(),c=i("p"),d=a(),m(b.$$.fragment),p=a(),M=i("p"),M.innerHTML=$e,te=a(),$=i("p"),$.innerHTML=Ae,ne=a(),m(x.$$.fragment),oe=a(),m(A.$$.fragment),ae=a(),C=i("p"),C.textContent=Ce,se=a(),I=i("p"),I.innerHTML=Ie,re=a(),m(j.$$.fragment),ie=a(),B=i("p"),B.innerHTML=je,le=a(),m(G.$$.fragment),pe=a(),m(P.$$.fragment),ce=a(),X=i("p"),X.innerHTML=Be,de=a(),m(E.$$.fragment),me=a(),N=i("p"),N.innerHTML=Ge,ue=a(),Q=i("p"),Q.textContent=Pe,fe=a(),W=i("p"),W.innerHTML=Xe,ge=a(),m(R.$$.fragment),he=a(),J=i("div"),m(q.$$.fragment),Je=a(),y=i("div"),m(z.$$.fragment),ve=a(),L=i("p"),L.textContent=Ee,Ue=a(),m(k.$$.fragment),Fe=a(),S=i("p"),S.innerHTML=Ne,xe=a(),Z=i("div"),m(Y.$$.fragment),ke=a(),D=i("p"),D.textContent=Qe,_e=a(),m(H.$$.fragment),we=a(),O=i("p"),this.h()},l(e){const t=He("svelte-u9bgzb",document.head);r=l(t,"META",{name:!0,content:!0}),t.forEach(n),U=s(e),c=l(e,"P",{}),K(c).forEach(n),d=s(e),u(b.$$.fragment,e),p=s(e),M=l(e,"P",{"data-svelte-h":!0}),w(M)!=="svelte-mz8sy4"&&(M.innerHTML=$e),te=s(e),$=l(e,"P",{"data-svelte-h":!0}),w($)!=="svelte-1tuv1oa"&&($.innerHTML=Ae),ne=s(e),u(x.$$.fragment,e),oe=s(e),u(A.$$.fragment,e),ae=s(e),C=l(e,"P",{"data-svelte-h":!0}),w(C)!=="svelte-1ou2pxc"&&(C.textContent=Ce),se=s(e),I=l(e,"P",{"data-svelte-h":!0}),w(I)!=="svelte-76czaq"&&(I.innerHTML=Ie),re=s(e),u(j.$$.fragment,e),ie=s(e),B=l(e,"P",{"data-svelte-h":!0}),w(B)!=="svelte-9873at"&&(B.innerHTML=je),le=s(e),u(G.$$.fragment,e),pe=s(e),u(P.$$.fragment,e),ce=s(e),X=l(e,"P",{"data-svelte-h":!0}),w(X)!=="svelte-10cvqm3"&&(X.innerHTML=Be),de=s(e),u(E.$$.fragment,e),me=s(e),N=l(e,"P",{"data-svelte-h":!0}),w(N)!=="svelte-mmsxgw"&&(N.innerHTML=Ge),ue=s(e),Q=l(e,"P",{"data-svelte-h":!0}),w(Q)!=="svelte-rc38yx"&&(Q.textContent=Pe),fe=s(e),W=l(e,"P",{"data-svelte-h":!0}),w(W)!=="svelte-1f14drt"&&(W.innerHTML=Xe),ge=s(e),u(R.$$.fragment,e),he=s(e),J=l(e,"DIV",{class:!0});var F=K(J);u(q.$$.fragment,F),Je=s(F),y=l(F,"DIV",{class:!0});var v=K(y);u(z.$$.fragment,v),ve=s(v),L=l(v,"P",{"data-svelte-h":!0}),w(L)!=="svelte-v78lg8"&&(L.textContent=Ee),Ue=s(v),u(k.$$.fragment,v),Fe=s(v),S=l(v,"P",{"data-svelte-h":!0}),w(S)!=="svelte-pgrz6i"&&(S.innerHTML=Ne),v.forEach(n),xe=s(F),Z=l(F,"DIV",{class:!0});var ye=K(Z);u(Y.$$.fragment,ye),ke=s(ye),D=l(ye,"P",{"data-svelte-h":!0}),w(D)!=="svelte-16q0ax1"&&(D.textContent=Qe),ye.forEach(n),F.forEach(n),_e=s(e),u(H.$$.fragment,e),we=s(e),O=l(e,"P",{}),K(O).forEach(n),this.h()},h(){ee(r,"name","hf:doc:metadata"),ee(r,"content",et),ee(y,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),ee(Z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),ee(J,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8")},m(e,t){T(document.head,r),o(e,U,t),o(e,c,t),o(e,d,t),f(b,e,t),o(e,p,t),o(e,M,t),o(e,te,t),o(e,$,t),o(e,ne,t),f(x,e,t),o(e,oe,t),f(A,e,t),o(e,ae,t),o(e,C,t),o(e,se,t),o(e,I,t),o(e,re,t),f(j,e,t),o(e,ie,t),o(e,B,t),o(e,le,t),f(G,e,t),o(e,pe,t),f(P,e,t),o(e,ce,t),o(e,X,t),o(e,de,t),f(E,e,t),o(e,me,t),o(e,N,t),o(e,ue,t),o(e,Q,t),o(e,fe,t),o(e,W,t),o(e,ge,t),f(R,e,t),o(e,he,t),o(e,J,t),f(q,J,null),T(J,Je),T(J,y),f(z,y,null),T(y,ve),T(y,L),T(y,Ue),f(k,y,null),T(y,Fe),T(y,S),T(J,xe),T(J,Z),f(Y,Z,null),T(Z,ke),T(Z,D),o(e,_e,t),f(H,e,t),o(e,we,t),o(e,O,t),be=!0},p(e,[t]){const F={};t&2&&(F.$$scope={dirty:t,ctx:e}),x.$set(F);const v={};t&2&&(v.$$scope={dirty:t,ctx:e}),k.$set(v)},i(e){be||(g(b.$$.fragment,e),g(x.$$.fragment,e),g(A.$$.fragment,e),g(j.$$.fragment,e),g(G.$$.fragment,e),g(P.$$.fragment,e),g(E.$$.fragment,e),g(R.$$.fragment,e),g(q.$$.fragment,e),g(z.$$.fragment,e),g(k.$$.fragment,e),g(Y.$$.fragment,e),g(H.$$.fragment,e),be=!0)},o(e){h(b.$$.fragment,e),h(x.$$.fragment,e),h(A.$$.fragment,e),h(j.$$.fragment,e),h(G.$$.fragment,e),h(P.$$.fragment,e),h(E.$$.fragment,e),h(R.$$.fragment,e),h(q.$$.fragment,e),h(z.$$.fragment,e),h(k.$$.fragment,e),h(Y.$$.fragment,e),h(H.$$.fragment,e),be=!1},d(e){e&&(n(U),n(c),n(d),n(p),n(M),n(te),n($),n(ne),n(oe),n(ae),n(C),n(se),n(I),n(re),n(ie),n(B),n(le),n(pe),n(ce),n(X),n(de),n(me),n(N),n(ue),n(Q),n(fe),n(W),n(ge),n(he),n(J),n(_e),n(we),n(O)),n(r),_(b,e),_(x,e),_(A,e),_(j,e),_(G,e),_(P,e),_(E,e),_(R,e),_(q),_(z),_(k),_(Y),_(H,e)}}}const et='{"title":"AuraFlow","local":"auraflow","sections":[{"title":"Quantization","local":"quantization","sections":[],"depth":2},{"title":"Support for torch.compile()","local":"support-for-torchcompile","sections":[],"depth":2},{"title":"AuraFlowPipeline","local":"diffusers.AuraFlowPipeline","sections":[],"depth":2}],"depth":1}';function tt(V){return qe(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class pt extends ze{constructor(r){super(),Ye(this,r,tt,Ke,Re,{})}}export{pt as component};
