import{s as Bu,o as Xu,n as N}from"../chunks/scheduler.b9285784.js";import{S as Zu,i as Yu,e as s,s as o,c as m,h as Qu,a as i,d as t,b as n,f as y,g as u,j as c,k as $,l as r,m as l,n as g,t as h,o as f,p as _}from"../chunks/index.26bc89a1.js";import{T as an}from"../chunks/Tip.e4eba3d6.js";import{C as Ku,H as M,E as eg}from"../chunks/MermaidChart.svelte_svelte_type_style_lang.e364eac2.js";import{D as x}from"../chunks/Docstring.43e9d871.js";import{C as lt}from"../chunks/CodeBlock.804615c8.js";import{E as rt}from"../chunks/ExampleCodeBlock.048c2422.js";function tg(k){let d,w="Example:",b,v,C;return v=new lt({props:{code:"ZnJvbSUyMGFjY2VsZXJhdGUlMjBpbXBvcnQlMjBBY2NlbGVyYXRvciUwQWZyb20lMjBhY2NlbGVyYXRlLnV0aWxzJTIwaW1wb3J0JTIwQXV0b2Nhc3RLd2FyZ3MlMEElMEFrd2FyZ3MlMjAlM0QlMjBBdXRvY2FzdEt3YXJncyhjYWNoZV9lbmFibGVkJTNEVHJ1ZSklMEFhY2NlbGVyYXRvciUyMCUzRCUyMEFjY2VsZXJhdG9yKGt3YXJnc19oYW5kbGVycyUzRCU1Qmt3YXJncyU1RCk=",highlighted:`<span class="hljs-keyword">from</span> accelerate <span class="hljs-keyword">import</span> Accelerator
<span class="hljs-keyword">from</span> accelerate.utils <span class="hljs-keyword">import</span> AutocastKwargs

kwargs = AutocastKwargs(cache_enabled=<span class="hljs-literal">True</span>)
accelerator = Accelerator(kwargs_handlers=[kwargs])`,wrap:!1}}),{c(){d=s("p"),d.textContent=w,b=o(),m(v.$$.fragment)},l(p){d=i(p,"P",{"data-svelte-h":!0}),c(d)!=="svelte-11lpom8"&&(d.textContent=w),b=n(p),u(v.$$.fragment,p)},m(p,T){l(p,d,T),l(p,b,T),g(v,p,T),C=!0},p:N,i(p){C||(h(v.$$.fragment,p),C=!0)},o(p){f(v.$$.fragment,p),C=!1},d(p){p&&(t(d),t(b)),_(v,p)}}}function ag(k){let d,w="<code>gradient_as_bucket_view</code> is only available in PyTorch 1.7.0 and later versions.",b,v,C="<code>static_graph</code> is only available in PyTorch 1.11.0 and later versions.";return{c(){d=s("p"),d.innerHTML=w,b=o(),v=s("p"),v.innerHTML=C},l(p){d=i(p,"P",{"data-svelte-h":!0}),c(d)!=="svelte-wnn996"&&(d.innerHTML=w),b=n(p),v=i(p,"P",{"data-svelte-h":!0}),c(v)!=="svelte-nj3kvq"&&(v.innerHTML=C)},m(p,T){l(p,d,T),l(p,b,T),l(p,v,T)},p:N,d(p){p&&(t(d),t(b),t(v))}}}function og(k){let d,w="Example:",b,v,C;return v=new lt({props:{code:"ZnJvbSUyMGFjY2VsZXJhdGUlMjBpbXBvcnQlMjBBY2NlbGVyYXRvciUwQWZyb20lMjBhY2NlbGVyYXRlLnV0aWxzJTIwaW1wb3J0JTIwRGlzdHJpYnV0ZWREYXRhUGFyYWxsZWxLd2FyZ3MlMEElMEFrd2FyZ3MlMjAlM0QlMjBEaXN0cmlidXRlZERhdGFQYXJhbGxlbEt3YXJncyhmaW5kX3VudXNlZF9wYXJhbWV0ZXJzJTNEVHJ1ZSklMEFhY2NlbGVyYXRvciUyMCUzRCUyMEFjY2VsZXJhdG9yKGt3YXJnc19oYW5kbGVycyUzRCU1Qmt3YXJncyU1RCk=",highlighted:`<span class="hljs-keyword">from</span> accelerate <span class="hljs-keyword">import</span> Accelerator
<span class="hljs-keyword">from</span> accelerate.utils <span class="hljs-keyword">import</span> DistributedDataParallelKwargs

kwargs = DistributedDataParallelKwargs(find_unused_parameters=<span class="hljs-literal">True</span>)
accelerator = Accelerator(kwargs_handlers=[kwargs])`,wrap:!1}}),{c(){d=s("p"),d.textContent=w,b=o(),m(v.$$.fragment)},l(p){d=i(p,"P",{"data-svelte-h":!0}),c(d)!=="svelte-11lpom8"&&(d.textContent=w),b=n(p),u(v.$$.fragment,p)},m(p,T){l(p,d,T),l(p,b,T),g(v,p,T),C=!0},p:N,i(p){C||(h(v.$$.fragment,p),C=!0)},o(p){f(v.$$.fragment,p),C=!1},d(p){p&&(t(d),t(b)),_(v,p)}}}function ng(k){let d,w=`<code>torch.cuda.amp.GradScaler</code> is only available in PyTorch 1.5.0 and later versions, and <code>torch.amp.GradScaler</code> is
only available in PyTorch 2.4.0 and later versions.`;return{c(){d=s("p"),d.innerHTML=w},l(b){d=i(b,"P",{"data-svelte-h":!0}),c(d)!=="svelte-7quoha"&&(d.innerHTML=w)},m(b,v){l(b,d,v)},p:N,d(b){b&&t(d)}}}function rg(k){let d,w="Example:",b,v,C;return v=new lt({props:{code:"ZnJvbSUyMGFjY2VsZXJhdGUlMjBpbXBvcnQlMjBBY2NlbGVyYXRvciUwQWZyb20lMjBhY2NlbGVyYXRlLnV0aWxzJTIwaW1wb3J0JTIwR3JhZFNjYWxlckt3YXJncyUwQSUwQWt3YXJncyUyMCUzRCUyMEdyYWRTY2FsZXJLd2FyZ3MoYmFja29mZl9mYWN0b3IlM0QwLjI1KSUwQWFjY2VsZXJhdG9yJTIwJTNEJTIwQWNjZWxlcmF0b3Ioa3dhcmdzX2hhbmRsZXJzJTNEJTVCa3dhcmdzJTVEKQ==",highlighted:`<span class="hljs-keyword">from</span> accelerate <span class="hljs-keyword">import</span> Accelerator
<span class="hljs-keyword">from</span> accelerate.utils <span class="hljs-keyword">import</span> GradScalerKwargs

kwargs = GradScalerKwargs(backoff_factor=<span class="hljs-number">0.25</span>)
accelerator = Accelerator(kwargs_handlers=[kwargs])`,wrap:!1}}),{c(){d=s("p"),d.textContent=w,b=o(),m(v.$$.fragment)},l(p){d=i(p,"P",{"data-svelte-h":!0}),c(d)!=="svelte-11lpom8"&&(d.textContent=w),b=n(p),u(v.$$.fragment,p)},m(p,T){l(p,d,T),l(p,b,T),g(v,p,T),C=!0},p:N,i(p){C||(h(v.$$.fragment,p),C=!0)},o(p){f(v.$$.fragment,p),C=!1},d(p){p&&(t(d),t(b)),_(v,p)}}}function lg(k){let d,w;return d=new lt({props:{code:"ZnJvbSUyMGRhdGV0aW1lJTIwaW1wb3J0JTIwdGltZWRlbHRhJTBBZnJvbSUyMGFjY2VsZXJhdGUlMjBpbXBvcnQlMjBBY2NlbGVyYXRvciUwQWZyb20lMjBhY2NlbGVyYXRlLnV0aWxzJTIwaW1wb3J0JTIwSW5pdFByb2Nlc3NHcm91cEt3YXJncyUwQSUwQWt3YXJncyUyMCUzRCUyMEluaXRQcm9jZXNzR3JvdXBLd2FyZ3ModGltZW91dCUzRHRpbWVkZWx0YShzZWNvbmRzJTNEODAwKSklMEFhY2NlbGVyYXRvciUyMCUzRCUyMEFjY2VsZXJhdG9yKGt3YXJnc19oYW5kbGVycyUzRCU1Qmt3YXJncyU1RCk=",highlighted:`<span class="hljs-keyword">from</span> datetime <span class="hljs-keyword">import</span> timedelta
<span class="hljs-keyword">from</span> accelerate <span class="hljs-keyword">import</span> Accelerator
<span class="hljs-keyword">from</span> accelerate.utils <span class="hljs-keyword">import</span> InitProcessGroupKwargs

kwargs = InitProcessGroupKwargs(timeout=timedelta(seconds=<span class="hljs-number">800</span>))
accelerator = Accelerator(kwargs_handlers=[kwargs])`,wrap:!1}}),{c(){m(d.$$.fragment)},l(b){u(d.$$.fragment,b)},m(b,v){g(d,b,v),w=!0},p:N,i(b){w||(h(d.$$.fragment,b),w=!0)},o(b){f(d.$$.fragment,b),w=!1},d(b){_(d,b)}}}function sg(k){let d,w="Example:",b,v,C;return v=new lt({props:{code:"ZnJvbSUyMGFjY2VsZXJhdGUudXRpbHMlMjBpbXBvcnQlMjBHcmFkaWVudEFjY3VtdWxhdGlvblBsdWdpbiUwQSUwQWdyYWRpZW50X2FjY3VtdWxhdGlvbl9wbHVnaW4lMjAlM0QlMjBHcmFkaWVudEFjY3VtdWxhdGlvblBsdWdpbihudW1fc3RlcHMlM0QyKSUwQWFjY2VsZXJhdG9yJTIwJTNEJTIwQWNjZWxlcmF0b3IoZ3JhZGllbnRfYWNjdW11bGF0aW9uX3BsdWdpbiUzRGdyYWRpZW50X2FjY3VtdWxhdGlvbl9wbHVnaW4p",highlighted:`<span class="hljs-keyword">from</span> accelerate.utils <span class="hljs-keyword">import</span> GradientAccumulationPlugin

gradient_accumulation_plugin = GradientAccumulationPlugin(num_steps=<span class="hljs-number">2</span>)
accelerator = Accelerator(gradient_accumulation_plugin=gradient_accumulation_plugin)`,wrap:!1}}),{c(){d=s("p"),d.textContent=w,b=o(),m(v.$$.fragment)},l(p){d=i(p,"P",{"data-svelte-h":!0}),c(d)!=="svelte-11lpom8"&&(d.textContent=w),b=n(p),u(v.$$.fragment,p)},m(p,T){l(p,d,T),l(p,b,T),g(v,p,T),C=!0},p:N,i(p){C||(h(v.$$.fragment,p),C=!0)},o(p){f(v.$$.fragment,p),C=!1},d(p){p&&(t(d),t(b)),_(v,p)}}}function ig(k){let d,w="Example:",b,v,C;return v=new lt({props:{code:"aW1wb3J0JTIwb3MlMEFmcm9tJTIwYWNjZWxlcmF0ZS51dGlscyUyMGltcG9ydCUyMHBhdGNoX2Vudmlyb25tZW50JTBBJTBBd2l0aCUyMHBhdGNoX2Vudmlyb25tZW50KEZPTyUzRCUyMmJhciUyMiklM0ElMEElMjAlMjAlMjAlMjBwcmludChvcy5lbnZpcm9uJTVCJTIyRk9PJTIyJTVEKSUyMCUyMCUyMyUyMHByaW50cyUyMCUyMmJhciUyMiUwQXByaW50KG9zLmVudmlyb24lNUIlMjJGT08lMjIlNUQpJTIwJTIwJTIzJTIwcmFpc2VzJTIwS2V5RXJyb3I=",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> os
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> accelerate.utils <span class="hljs-keyword">import</span> patch_environment

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">with</span> patch_environment(FOO=<span class="hljs-string">&quot;bar&quot;</span>):
<span class="hljs-meta">... </span>    <span class="hljs-built_in">print</span>(os.environ[<span class="hljs-string">&quot;FOO&quot;</span>])  <span class="hljs-comment"># prints &quot;bar&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-built_in">print</span>(os.environ[<span class="hljs-string">&quot;FOO&quot;</span>])  <span class="hljs-comment"># raises KeyError</span>`,wrap:!1}}),{c(){d=s("p"),d.textContent=w,b=o(),m(v.$$.fragment)},l(p){d=i(p,"P",{"data-svelte-h":!0}),c(d)!=="svelte-11lpom8"&&(d.textContent=w),b=n(p),u(v.$$.fragment,p)},m(p,T){l(p,d,T),l(p,b,T),g(v,p,T),C=!0},p:N,i(p){C||(h(v.$$.fragment,p),C=!0)},o(p){f(v.$$.fragment,p),C=!1},d(p){p&&(t(d),t(b)),_(v,p)}}}function cg(k){let d,w="Example:",b,v,C;return v=new lt({props:{code:"aW1wb3J0JTIwb3MlMEFmcm9tJTIwYWNjZWxlcmF0ZS51dGlscyUyMGltcG9ydCUyMGNsZWFyX2Vudmlyb25tZW50JTBBJTBBb3MuZW52aXJvbiU1QiUyMkZPTyUyMiU1RCUyMCUzRCUyMCUyMmJhciUyMiUwQXdpdGglMjBjbGVhcl9lbnZpcm9ubWVudCgpJTNBJTBBJTIwJTIwJTIwJTIwcHJpbnQob3MuZW52aXJvbiklMEElMjAlMjAlMjAlMjBvcy5lbnZpcm9uJTVCJTIyRk9PJTIyJTVEJTIwJTNEJTIwJTIybmV3X2JhciUyMiUwQSUyMCUyMCUyMCUyMHByaW50KG9zLmVudmlyb24lNUIlMjJGT08lMjIlNUQpJTBBJTBBcHJpbnQob3MuZW52aXJvbiU1QiUyMkZPTyUyMiU1RCk=",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> os
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> accelerate.utils <span class="hljs-keyword">import</span> clear_environment

<span class="hljs-meta">&gt;&gt;&gt; </span>os.environ[<span class="hljs-string">&quot;FOO&quot;</span>] = <span class="hljs-string">&quot;bar&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">with</span> clear_environment():
<span class="hljs-meta">... </span>    <span class="hljs-built_in">print</span>(os.environ)
<span class="hljs-meta">... </span>    os.environ[<span class="hljs-string">&quot;FOO&quot;</span>] = <span class="hljs-string">&quot;new_bar&quot;</span>
<span class="hljs-meta">... </span>    <span class="hljs-built_in">print</span>(os.environ[<span class="hljs-string">&quot;FOO&quot;</span>])
{}
new_bar

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-built_in">print</span>(os.environ[<span class="hljs-string">&quot;FOO&quot;</span>])
bar`,wrap:!1}}),{c(){d=s("p"),d.textContent=w,b=o(),m(v.$$.fragment)},l(p){d=i(p,"P",{"data-svelte-h":!0}),c(d)!=="svelte-11lpom8"&&(d.textContent=w),b=n(p),u(v.$$.fragment,p)},m(p,T){l(p,d,T),l(p,b,T),g(v,p,T),C=!0},p:N,i(p){C||(h(v.$$.fragment,p),C=!0)},o(p){f(v.$$.fragment,p),C=!1},d(p){p&&(t(d),t(b)),_(v,p)}}}function dg(k){let d,w="Example:",b,v,C;return v=new lt({props:{code:"ZnJvbSUyMGFjY2VsZXJhdGUudXRpbHMlMjBpbXBvcnQlMjBmaW5kX2V4ZWN1dGFibGVfYmF0Y2hfc2l6ZSUwQSUwQSUwQSU0MGZpbmRfZXhlY3V0YWJsZV9iYXRjaF9zaXplKHN0YXJ0aW5nX2JhdGNoX3NpemUlM0QxMjgpJTBBZGVmJTIwdHJhaW4oYmF0Y2hfc2l6ZSUyQyUyMG1vZGVsJTJDJTIwb3B0aW1pemVyKSUzQSUwQSUyMCUyMCUyMCUyMC4uLiUwQSUwQSUwQXRyYWluKG1vZGVsJTJDJTIwb3B0aW1pemVyKQ==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> accelerate.utils <span class="hljs-keyword">import</span> find_executable_batch_size


<span class="hljs-meta">&gt;&gt;&gt; </span>@find_executable_batch_size(starting_batch_size=<span class="hljs-number">128</span>)
<span class="hljs-meta">... </span><span class="hljs-keyword">def</span> <span class="hljs-title function_">train</span>(<span class="hljs-params">batch_size, model, optimizer</span>):
<span class="hljs-meta">... </span>    ...


<span class="hljs-meta">&gt;&gt;&gt; </span>train(model, optimizer)`,wrap:!1}}),{c(){d=s("p"),d.textContent=w,b=o(),m(v.$$.fragment)},l(p){d=i(p,"P",{"data-svelte-h":!0}),c(d)!=="svelte-11lpom8"&&(d.textContent=w),b=n(p),u(v.$$.fragment,p)},m(p,T){l(p,d,T),l(p,b,T),g(v,p,T),C=!0},p:N,i(p){C||(h(v.$$.fragment,p),C=!0)},o(p){f(v.$$.fragment,p),C=!1},d(p){p&&(t(d),t(b)),_(v,p)}}}function pg(k){let d,w=`All computation is done analyzing sizes and dtypes of the model parameters. As a result, the model can be on the
meta device (as it would if initialized within the <code>init_empty_weights</code> context manager).`;return{c(){d=s("p"),d.innerHTML=w},l(b){d=i(b,"P",{"data-svelte-h":!0}),c(d)!=="svelte-1d9m3bn"&&(d.innerHTML=w)},m(b,v){l(b,d,v)},p:N,d(b){b&&t(d)}}}function mg(k){let d,w=`All computation is done analyzing sizes and dtypes of the model parameters. As a result, the model can be on the
meta device (as it would if initialized within the <code>init_empty_weights</code> context manager).`;return{c(){d=s("p"),d.innerHTML=w},l(b){d=i(b,"P",{"data-svelte-h":!0}),c(d)!=="svelte-1d9m3bn"&&(d.innerHTML=w)},m(b,v){l(b,d,v)},p:N,d(b){b&&t(d)}}}function ug(k){let d,w=`Once loaded across devices, you still need to call <a href="/docs/accelerate/main/en/package_reference/big_modeling#accelerate.dispatch_model">dispatch_model()</a> on your model to make it able to run. To
group the checkpoint loading and dispatch in one single call, use <a href="/docs/accelerate/main/en/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch">load_checkpoint_and_dispatch()</a>.`;return{c(){d=s("p"),d.innerHTML=w},l(b){d=i(b,"P",{"data-svelte-h":!0}),c(d)!=="svelte-13sragn"&&(d.innerHTML=w)},m(b,v){l(b,d,v)},p:N,d(b){b&&t(d)}}}function gg(k){let d,w="Make sure all processes will reach this instruction otherwise one of your processes will hang forever.";return{c(){d=s("p"),d.textContent=w},l(b){d=i(b,"P",{"data-svelte-h":!0}),c(d)!=="svelte-1ejfkli"&&(d.textContent=w)},m(b,v){l(b,d,v)},p:N,d(b){b&&t(d)}}}function hg(k){let d,w="Example:",b,v,C;return v=new lt({props:{code:"ZnJvbSUyMGFjY2VsZXJhdGUudXRpbHMlMjBpbXBvcnQlMjBpbnN0YWxsX3hsYSUwQSUwQWluc3RhbGxfeGxhKHVwZ3JhZGUlM0RUcnVlKQ==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> accelerate.utils <span class="hljs-keyword">import</span> install_xla

<span class="hljs-meta">&gt;&gt;&gt; </span>install_xla(upgrade=<span class="hljs-literal">True</span>)`,wrap:!1}}),{c(){d=s("p"),d.textContent=w,b=o(),m(v.$$.fragment)},l(p){d=i(p,"P",{"data-svelte-h":!0}),c(d)!=="svelte-11lpom8"&&(d.textContent=w),b=n(p),u(v.$$.fragment,p)},m(p,T){l(p,d,T),l(p,b,T),g(v,p,T),C=!0},p:N,i(p){C||(h(v.$$.fragment,p),C=!0)},o(p){f(v.$$.fragment,p),C=!1},d(p){p&&(t(d),t(b)),_(v,p)}}}function fg(k){let d,w=`Once loaded across devices, you still need to call <a href="/docs/accelerate/main/en/package_reference/big_modeling#accelerate.dispatch_model">dispatch_model()</a> on your model to make it able to run. To
group the checkpoint loading and dispatch in one single call, use <a href="/docs/accelerate/main/en/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch">load_checkpoint_and_dispatch()</a>.`;return{c(){d=s("p"),d.innerHTML=w},l(b){d=i(b,"P",{"data-svelte-h":!0}),c(d)!=="svelte-13sragn"&&(d.innerHTML=w)},m(b,v){l(b,d,v)},p:N,d(b){b&&t(d)}}}function _g(k){let d,w,b,v,C,p,T,dl,zt,Mp="Below are a variety of utility functions that 🤗 Accelerate provides, broken down by use-case.",pl,Et,ml,It,Lp="Constants used throughout 🤗 Accelerate for reference",ul,At,Np='The following are constants used when utilizing <a href="/docs/accelerate/main/en/package_reference/accelerator#accelerate.Accelerator.save_state">Accelerator.save_state()</a>',gl,St,Dp="<code>utils.MODEL_NAME</code>: <code>&quot;pytorch_model&quot;</code> <code>utils.OPTIMIZER_NAME</code>: <code>&quot;optimizer&quot;</code> <code>utils.RNG_STATE_NAME</code>: <code>&quot;random_states&quot;</code> <code>utils.SCALER_NAME</code>: <code>&quot;scaler.pt</code> <code>utils.SCHEDULER_NAME</code>: <code>&quot;scheduler</code>",hl,Ot,Up='The following are constants used when utilizing <a href="/docs/accelerate/main/en/package_reference/accelerator#accelerate.Accelerator.save_model">Accelerator.save_model()</a>',fl,Vt,jp="<code>utils.WEIGHTS_NAME</code>: <code>&quot;pytorch_model.bin&quot;</code> <code>utils.SAFE_WEIGHTS_NAME</code>: <code>&quot;model.safetensors&quot;</code> <code>utils.WEIGHTS_INDEX_NAME</code>: <code>&quot;pytorch_model.bin.index.json&quot;</code> <code>utils.SAFE_WEIGHTS_INDEX_NAME</code>: <code>&quot;model.safetensors.index.json&quot;</code>",_l,qt,bl,Rt,Fp="These are basic dataclasses used throughout 🤗 Accelerate and they can be passed in as parameters.",vl,Ht,yl,Wt,zp="These are standalone dataclasses used for checks, such as the type of distributed system being used",$l,U,Gt,cc,on,Ep="Represents a type of the compute environment.",dc,nn,Ip="Values:",pc,rn,Ap="<li><strong>LOCAL_MACHINE</strong> — private/custom cluster hardware.</li> <li><strong>AMAZON_SAGEMAKER</strong> — Amazon SageMaker as compute environment.</li>",xl,j,Jt,mc,ln,Sp="Represents a type of distributed environment.",uc,sn,Op="Values:",gc,cn,Vp="<li><strong>NO</strong> — Not a distributed environment, just a single process.</li> <li><strong>MULTI_CPU</strong> — Distributed on multiple CPU nodes.</li> <li><strong>MULTI_GPU</strong> — Distributed on multiple GPUs.</li> <li><strong>MULTI_MLU</strong> — Distributed on multiple MLUs.</li> <li><strong>MULTI_SDAA</strong> — Distributed on multiple SDAAs.</li> <li><strong>MULTI_MUSA</strong> — Distributed on multiple MUSAs.</li> <li><strong>MULTI_NPU</strong> — Distributed on multiple NPUs.</li> <li><strong>MULTI_XPU</strong> — Distributed on multiple XPUs.</li> <li><strong>MULTI_HPU</strong> — Distributed on multiple HPUs.</li> <li><strong>DEEPSPEED</strong> — Using DeepSpeed.</li> <li><strong>XLA</strong> — Using TorchXLA.</li>",wl,F,Bt,hc,dn,qp='Represents a dynamo backend (see <a href="https://pytorch.org/docs/stable/torch.compiler.html" rel="nofollow">https://pytorch.org/docs/stable/torch.compiler.html</a>).',fc,pn,Rp="Values:",_c,mn,Hp=`<li><strong>NO</strong> — Do not use torch dynamo.</li> <li><strong>EAGER</strong> — Uses PyTorch to run the extracted GraphModule. This is quite useful in debugging TorchDynamo
issues.</li> <li><strong>AOT_EAGER</strong> — Uses AotAutograd with no compiler, i.e, just using PyTorch eager for the AotAutograd’s
extracted forward and backward graphs. This is useful for debugging, and unlikely to give speedups.</li> <li><strong>INDUCTOR</strong> — Uses TorchInductor backend with AotAutograd and cudagraphs by leveraging codegened Triton
kernels. <a href="https://dev-discuss.pytorch.org/t/torchinductor-a-pytorch-native-compiler-with-define-by-run-ir-and-symbolic-shapes/747" rel="nofollow">Read
more</a></li> <li><strong>AOT_TS_NVFUSER</strong> — nvFuser with AotAutograd/TorchScript. <a href="https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593" rel="nofollow">Read
more</a></li> <li><strong>NVPRIMS_NVFUSER</strong> — nvFuser with PrimTorch. <a href="https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593" rel="nofollow">Read
more</a></li> <li><strong>CUDAGRAPHS</strong> — cudagraphs with AotAutograd. <a href="https://github.com/pytorch/torchdynamo/pull/757" rel="nofollow">Read more</a></li> <li><strong>OFI</strong> — Uses Torchscript optimize_for_inference. Inference only. <a href="https://pytorch.org/docs/stable/generated/torch.jit.optimize_for_inference.html" rel="nofollow">Read
more</a></li> <li><strong>FX2TRT</strong> — Uses Nvidia TensorRT for inference optimizations. Inference only. <a href="https://github.com/pytorch/TensorRT/blob/master/docsrc/tutorials/getting_started_with_fx_path.rst" rel="nofollow">Read
more</a></li> <li><strong>ONNXRT</strong> — Uses ONNXRT for inference on CPU/GPU. Inference only. <a href="https://onnxruntime.ai/" rel="nofollow">Read more</a></li> <li><strong>TENSORRT</strong> — Uses ONNXRT to run TensorRT for inference optimizations. <a href="https://github.com/onnx/onnx-tensorrt" rel="nofollow">Read
more</a></li> <li><strong>AOT_TORCHXLA_TRACE_ONCE</strong> — Uses Pytorch/XLA with TorchDynamo optimization, for training. <a href="https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md" rel="nofollow">Read
more</a></li> <li><strong>TORCHXLA_TRACE_ONCE</strong> — Uses Pytorch/XLA with TorchDynamo optimization, for inference. <a href="https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md" rel="nofollow">Read
more</a></li> <li><strong>IPEX</strong> — Uses IPEX for inference on CPU. Inference only. <a href="https://github.com/intel/intel-extension-for-pytorch" rel="nofollow">Read
more</a>.</li> <li><strong>TVM</strong> — Uses Apache TVM for inference optimizations. <a href="https://tvm.apache.org/" rel="nofollow">Read more</a></li> <li><strong>HPU_BACKEND</strong> — Uses HPU backend for inference optimizations.</li>`,Cl,z,Xt,bc,un,Wp="Represents a type of supported experiment tracker",vc,gn,Gp="Values:",yc,hn,Jp="<li><strong>ALL</strong> — all available trackers in the environment that are supported</li> <li><strong>TENSORBOARD</strong> — TensorBoard as an experiment tracker</li> <li><strong>WANDB</strong> — wandb as an experiment tracker</li> <li><strong>TRACKIO</strong> — trackio as an experiment tracker</li> <li><strong>COMETML</strong> — comet_ml as an experiment tracker</li> <li><strong>MLFLOW</strong> — mlflow as an experiment tracker</li> <li><strong>CLEARML</strong> — clearml as an experiment tracker</li> <li><strong>DVCLIVE</strong> — dvclive as an experiment tracker</li> <li><strong>SWANLAB</strong> — swanlab as an experiment tracker</li>",Tl,E,Zt,$c,fn,Bp="Represents a type of precision used on floating point values",xc,_n,Xp="Values:",wc,bn,Zp="<li><strong>NO</strong> — using full precision (FP32)</li> <li><strong>FP16</strong> — using half precision</li> <li><strong>BF16</strong> — using brain floating point precision</li>",kl,he,Yt,Cc,vn,Yp="An enumeration.",Pl,I,Qt,Tc,yn,Qp="Represents a type of distributed environment.",kc,$n,Kp="Values:",Pc,xn,em="<li><strong>NO</strong> — Not a distributed environment, just a single process.</li> <li><strong>DATA_PARALLEL</strong> — using sagemaker distributed data parallelism.</li> <li><strong>MODEL_PARALLEL</strong> — using sagemaker distributed model parallelism.</li>",Ml,Kt,Ll,ea,tm="These are configurable arguments for specific interactions throughout the PyTorch ecosystem that Accelerate handles under the hood.",Nl,J,ta,Mc,wn,am=`Use this object in your <a href="/docs/accelerate/main/en/package_reference/accelerator#accelerate.Accelerator">Accelerator</a> to customize how <code>torch.autocast</code> behaves. Please refer to the
documentation of this <a href="https://pytorch.org/docs/stable/amp.html#torch.autocast" rel="nofollow">context manager</a> for more
information on each argument.`,Lc,st,Dl,A,aa,Nc,Cn,om=`Use this object in your <a href="/docs/accelerate/main/en/package_reference/accelerator#accelerate.Accelerator">Accelerator</a> to customize how your model is wrapped in a
<code>torch.nn.parallel.DistributedDataParallel</code>. Please refer to the documentation of this
<a href="https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html" rel="nofollow">wrapper</a> for more
information on each argument.`,Dc,it,Uc,ct,Ul,fe,oa,jc,Tn,nm=`Deprecated. Please use one of the proper FP8 recipe kwargs classes such as <code>TERecipeKwargs</code> or <code>MSAMPRecipeKwargs</code>
instead.`,jl,S,na,Fc,kn,rm=`Use this object in your <a href="/docs/accelerate/main/en/package_reference/accelerator#accelerate.Accelerator">Accelerator</a> to customize the behavior of mixed precision, specifically how the
<code>torch.amp.GradScaler</code> or <code>torch.cuda.amp.GradScaler</code> used is created. Please refer to the documentation of this
<a href="https://pytorch.org/docs/stable/amp.html?highlight=gradscaler" rel="nofollow">scaler</a> for more information on each argument.`,zc,dt,Ec,pt,Fl,O,ra,Ic,Pn,lm=`Use this object in your <a href="/docs/accelerate/main/en/package_reference/accelerator#accelerate.Accelerator">Accelerator</a> to customize the initialization of the distributed processes. Please refer
to the documentation of this
<a href="https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group" rel="nofollow">method</a> for more
information on each argument.`,Ac,Mn,sm="Note: If <code>timeout</code> is set to <code>None</code>, the default will be based upon how <code>backend</code> is set.",Sc,mt,zl,B,la,Oc,Ln,im="Internal mixin that implements a <code>to_kwargs()</code> method for a dataclass.",Vc,ut,sa,qc,Nn,cm="Returns a dictionary containing the attributes with values different from the default of this class.",El,ia,Il,ca,dm=`These are plugins that can be passed to the <a href="/docs/accelerate/main/en/package_reference/accelerator#accelerate.Accelerator">Accelerator</a> object. While they are defined elsewhere in the documentation,
for convenience all of them are available to see here:`,Al,V,da,Rc,Dn,pm="This plugin is used to integrate DeepSpeed.",Hc,gt,pa,Wc,Un,mm="Process the DeepSpeed config with the values from the kwargs.",Gc,ht,ma,Jc,jn,um="Sets the HfDeepSpeedWeakref to use the current deepspeed plugin configuration",Sl,L,ua,Bc,Fn,gm="This plugin is used to enable fully sharded data parallelism.",Xc,ft,ga,Zc,zn,hm=`Given <code>model</code>, creates an <code>auto_wrap_policy</code> based on the passed in policy and if we can use the
<code>transformer_cls_to_wrap</code>`,Yc,_t,ha,Qc,En,fm="Sets the mixed precision policy for FSDP",Kc,bt,fa,ed,In,_m="Set the state dict config based on the <code>StateDictType</code>.",td,vt,_a,ad,An,bm="Validates the mixed precision policy, abstracted away to not bring in the imports if not needed.",Ol,X,ba,od,Sn,vm=`A plugin to configure gradient accumulation behavior. You can only pass one of <code>gradient_accumulation_plugin</code> or
<code>gradient_accumulation_steps</code> to <a href="/docs/accelerate/main/en/package_reference/accelerator#accelerate.Accelerator">Accelerator</a>. Passing both raises an error.`,nd,yt,Vl,_e,va,rd,On,ym=`Plugin for Megatron-LM to enable tensor, pipeline, sequence and data parallelism. Also to enable selective
activation recomputation and optimized fused kernels.`,ql,be,ya,ld,Vn,$m="This plugin is used to compile a model with PyTorch 2.0",Rl,$a,Hl,xa,xm="These are classes which can be configured and passed through to the appropriate integration",Wl,ve,wa,sd,qn,wm="A plugin to enable BitsAndBytes 4bit and 8bit quantization",Gl,ye,Ca,id,Rn,Cm="Configuration for dataloader-related items when calling <code>accelerator.prepare</code>.",Jl,Z,Ta,cd,Hn,Tm="Configuration for the Accelerator object based on inner-project needs.",dd,$t,ka,pd,Wn,km="Sets <code>self.project_dir</code> and <code>self.logging_dir</code> to the appropriate values.",Bl,Pa,Xl,Ma,Pm="These are environmental variables that can be enabled for different use cases",Zl,La,Mm='<li><code>ACCELERATE_DEBUG_MODE</code> (<code>str</code>): Whether to run accelerate in debug mode. More info available <a href="../usage_guides/debug.md">here</a>.</li>',Yl,Na,Ql,Da,Lm="These include data operations that mimic the same <code>torch</code> ops but can be used on distributed processes.",Kl,$e,Ua,md,Gn,Nm="Recursively broadcast tensor in a nested list/tuple/dictionary of tensors to all devices.",es,xe,ja,ud,Jn,Dm="Broadcast a list of picklable objects form one process to the others.",ts,we,Fa,gd,Bn,Um="Recursively concatenate the tensors in a nested list/tuple/dictionary of lists of tensors with the same shape.",as,za,Ea,os,Ce,Ia,hd,Xn,jm="Recursively converts the elements nested list/tuple/dictionary of tensors in FP16/BF16 precision to FP32.",ns,Te,Aa,fd,Zn,Fm="Recursively gather tensor in a nested list/tuple/dictionary of tensors from all devices.",rs,ke,Sa,_d,Yn,zm="Recursively gather object in a nested list/tuple/dictionary of objects from all devices.",ls,Pe,Oa,bd,Qn,Em=`A generic helper which will initialize the correct <code>GradScaler</code> implementation based on the environment and return
it.`,ss,Me,Va,vd,Kn,Im="Return a context manager for autocasting mixed precision",is,Le,qa,yd,er,Am="Recursively finds tensors in a nested list/tuple/dictionary and converts them to a list of numbers.",cs,Ne,Ra,$d,tr,Sm=`Recursively pad the tensors in a nested list/tuple/dictionary of tensors from all devices to the same size so they
can safely be gathered.`,ds,De,Ha,xd,ar,Om="Recursively apply a function on a data structure that is a nested list/tuple/dictionary of a given base type.",ps,Ue,Wa,wd,or,Vm=`Recursively reduce the tensors in a nested list/tuple/dictionary of lists of tensors across all processes by the
mean of a given operation.`,ms,je,Ga,Cd,nr,qm="Recursively sends the elements in a nested list/tuple/dictionary of tensors to a given device.",us,Fe,Ja,Td,rr,Rm="Recursively takes a slice in a nested list/tuple/dictionary of tensors.",gs,Ba,hs,Xa,Hm="These functionalities check the state of the current working environment including information about the operating system itself, what it can support, and if particular dependencies are installed.",fs,ze,Za,kd,lr,Wm="Checks if bf16 is supported, optionally ignoring the TPU",_s,Ee,Ya,Pd,sr,Gm="Checks if ipex is installed.",bs,Ie,Qa,Md,ir,Jm="Checks if MPS device is available. The minimum version required is 1.12.",vs,Ae,Ka,Ld,cr,Bm="Checks if <code>torch_npu</code> is installed and potentially if a NPU is in the environment",ys,Se,eo,Nd,dr,Xm="Compares the current PyTorch version to a given reference with an operation.",$s,Oe,to,Dd,pr,Zm=`Check if <code>torch_xla</code> is available. To train a native pytorch job in an environment with torch xla installed, set
the USE_TORCH_XLA to false.`,xs,Ve,ao,Ud,mr,Ym=`Checks if XPU acceleration is available either via <code>intel_extension_for_pytorch</code> or via stock PyTorch (&gt;=2.4) and
potentially if a XPU is in the environment`,ws,oo,Cs,q,no,jd,ur,Qm="A context manager that will add each keyword argument passed to <code>os.environ</code> and remove them when exiting.",Fd,gr,Km="Will convert the values in <code>kwargs</code> to strings and upper-case all the keys.",zd,xt,Ts,R,ro,Ed,hr,eu="A context manager that will temporarily clear environment variables.",Id,fr,tu="When this context exits, the previous environment variables will be back.",Ad,wt,ks,qe,lo,Sd,_r,au=`Creates and saves a basic cluster config to be used on a local machine with potentially multiple GPUs. Will also
set CPU if it is a CPU-only machine.`,Ps,so,ou="When setting up 🤗 Accelerate for the first time, rather than running <code>accelerate config</code> [~utils.write_basic_config] can be used as an alternative for quick configuration.",Ms,Y,io,Od,br,nu="Assigns the current process to a specific NUMA node. Ideally most efficient when having at least 2 cpus per node.",Vd,vr,ru=`This result is cached between calls. If you want to override it, please use
<code>accelerate.utils.environment.override_numa_afifnity</code>.`,Ls,Re,co,qd,yr,lu=`Overrides whatever NUMA affinity is set for the current process. This is very taxing and requires recalculating the
affinity to set, ideally you should use <code>utils.environment.set_numa_affinity</code> instead.`,Ns,P,po,Rd,$r,su="Decorator to clean up accelerate environment variables set by the decorated class or function.",Hd,xr,iu=`In some circumstances, calling certain classes or functions can result in accelerate env vars being set and not
being cleaned up afterwards. As an example, when calling:`,Wd,wr,cu="TrainingArguments(fp16=True, …)",Gd,Cr,du="The following env var will be set:",Jd,Tr,pu="ACCELERATE_MIXED_PRECISION=fp16",Bd,kr,mu=`This can affect subsequent code, since the env var takes precedence over TrainingArguments(fp16=False). This is
especially relevant for unit testing, where we want to avoid the individual tests to have side effects on one
another. Decorate the unit test function or whole class with this decorator to ensure that after each test, the env
vars are cleaned up. This works for both unittest.TestCase and normal classes (pytest); it also works when
decorating the parent class.`,Ds,mo,Us,H,uo,Xd,Pr,uu=`A basic decorator that will try to execute <code>function</code>. If it fails from exceptions related to out-of-memory or
CUDNN, the batch size is multiplied by 0.9 and passed to <code>function</code>`,Zd,Mr,gu="<code>function</code> must take in a <code>batch_size</code> parameter as its first argument.",Yd,Ct,js,go,Fs,ho,hu="These utilities relate to interacting with PyTorch models",zs,He,fo,Qd,Lr,fu="Computes the total size of the model and its largest layer",Es,We,_o,Kd,Nr,_u="Compute the size of each submodule of a given model.",Is,Ge,bo,ep,Dr,bu="Extract a model from its distributed containers.",As,Q,vo,tp,Ur,vu='Compute a <code>max_memory</code> dictionary for <a href="/docs/accelerate/main/en/package_reference/big_modeling#accelerate.infer_auto_device_map">infer_auto_device_map()</a> that will balance the use of each available GPU.',ap,Tt,Ss,K,yo,op,jr,yu=`Utility function that will scan a list of named modules and return the maximum size used by one full layer. The
definition of a layer being:`,np,Fr,$u="<li>a module with no direct children (just parameters and buffers)</li> <li>a module whose class name is in the list <code>no_split_module_classes</code></li>",Os,W,$o,rp,zr,xu=`Compute a device map for a given model giving priority to GPUs, then offload on CPU and finally offload to disk,
such that:`,lp,Er,wu=`<li>we don’t exceed the memory available of any of the GPU.</li> <li>if offload to the CPU is needed, there is always room left on GPU 0 to put back the layer offloaded on CPU that
has the largest size.</li> <li>if offload to the CPU is needed,we don’t exceed the RAM available on the CPU.</li> <li>if offload to the disk is needed, there is always room left on the CPU to put back the layer offloaded on disk
that has the largest size.</li>`,sp,kt,Vs,ee,xo,ip,Ir,Cu=`Loads a (potentially sharded) checkpoint inside a model, potentially sending weights to a given device as they are
loaded.`,cp,Pt,qs,Je,wo,dp,Ar,Tu="Loads the weights from the offload folder into the model.",Rs,Be,Co,pp,Sr,ku=`Load a checkpoint from a given file. If the checkpoint is in the safetensors format and a device map is passed, the
weights can be fast-loaded directly on the GPU.`,Hs,Xe,To,mp,Or,Pu="Offload a state dict in a given folder.",Ws,Ze,ko,up,Vr,Mu="Reties tied parameters in a given model if the link was broken (for instance when adding hooks).",Gs,Ye,Po,gp,qr,Lu=`A helper function to set a given tensor (parameter of buffer) of a module on a specific device (note that doing
<code>param.to(device)</code> creates a new tensor not linked to the parameter, which is why we need this function).`,Js,Qe,Mo,hp,Rr,Nu="Traverse the model in bottom-up order and return the children modules in that order.",Bs,Lo,Xs,No,Du="These include general utilities that should be used when working in parallel.",Zs,Ke,Do,fp,Hr,Uu="Extract a model from its distributed containers.",Ys,et,Uo,_p,Wr,ju="Save the data to disk. Use in place of <code>torch.save()</code>.",Qs,te,jo,bp,Gr,Fu=`Compatible drop-in replacement of <code>torch.load()</code> which allows for <code>weights_only</code> to be used if <code>torch</code> version is
2.4.0 or higher. Otherwise will ignore the kwarg.`,vp,Jr,zu="Will also add (and then remove) an exception for numpy arrays",Ks,ae,Fo,yp,Br,Eu="Introduces a blocking point in the script, making sure all processes have reached this point before continuing.",$p,Mt,ei,zo,ti,Eo,Iu="These utilities relate to setting and synchronizing of all the random states.",ai,tt,Io,xp,Xr,Au="Helper function for reproducible behavior to set the seed in <code>random</code>, <code>numpy</code>, <code>torch</code>.",oi,Ao,So,ni,Oo,Vo,ri,qo,li,Ro,Su="These include utilities that are useful while using PyTorch with XLA.",si,oe,Ho,wp,Zr,Ou="Helper function to install appropriate xla wheels based on the <code>torch</code> version in Google Colaboratory.",Cp,Lt,ii,Wo,ci,Go,Vu="These include utilities that are useful to load checkpoints.",di,ne,Jo,Tp,Yr,qu=`Loads a (potentially sharded) checkpoint inside a model, potentially sending weights to a given device as they are
loaded.`,kp,Nt,pi,Bo,mi,Xo,Ru="These include utilities that are useful to quantize model.",ui,at,Zo,Pp,Qr,Hu=`This function will quantize the input model with the associated config passed in <code>bnb_quantization_config</code>. If the
model is in the meta device, we will load and dispatch the weights according to the <code>device_map</code> passed. If the
model is already loaded, we will quantize the model and put the model on the GPU,`,gi,Yo,hi,cl,fi;return C=new Ku({props:{containerStyle:"float: right; margin-left: 10px; display: inline-flex; position: relative; z-index: 10;"}}),T=new M({props:{title:"Utility functions and classes",local:"utility-functions-and-classes",headingTag:"h1"}}),Et=new M({props:{title:"Constants",local:"constants",headingTag:"h2"}}),qt=new M({props:{title:"Data Classes",local:"data-classes",headingTag:"h2"}}),Ht=new M({props:{title:"Standalone",local:"accelerate.utils.ComputeEnvironment",headingTag:"h3"}}),Gt=new x({props:{name:"class accelerate.utils.ComputeEnvironment",anchor:"accelerate.utils.ComputeEnvironment",parameters:[{name:"value",val:""},{name:"names",val:" = None"},{name:"module",val:" = None"},{name:"qualname",val:" = None"},{name:"type",val:" = None"},{name:"start",val:" = 1"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L639"}}),Jt=new x({props:{name:"class accelerate.DistributedType",anchor:"accelerate.DistributedType",parameters:[{name:"value",val:""},{name:"names",val:" = None"},{name:"module",val:" = None"},{name:"qualname",val:" = None"},{name:"type",val:" = None"},{name:"start",val:" = 1"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L570"}}),Bt=new x({props:{name:"class accelerate.utils.DynamoBackend",anchor:"accelerate.utils.DynamoBackend",parameters:[{name:"value",val:""},{name:"names",val:" = None"},{name:"module",val:" = None"},{name:"qualname",val:" = None"},{name:"type",val:" = None"},{name:"start",val:" = 1"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L654"}}),Xt=new x({props:{name:"class accelerate.utils.LoggerType",anchor:"accelerate.utils.LoggerType",parameters:[{name:"value",val:""},{name:"names",val:" = None"},{name:"module",val:" = None"},{name:"qualname",val:" = None"},{name:"type",val:" = None"},{name:"start",val:" = 1"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L710"}}),Zt=new x({props:{name:"class accelerate.utils.PrecisionType",anchor:"accelerate.utils.PrecisionType",parameters:[{name:"value",val:""},{name:"names",val:" = None"},{name:"module",val:" = None"},{name:"qualname",val:" = None"},{name:"type",val:" = None"},{name:"start",val:" = 1"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L738"}}),Yt=new x({props:{name:"class accelerate.utils.RNGType",anchor:"accelerate.utils.RNGType",parameters:[{name:"value",val:""},{name:"names",val:" = None"},{name:"module",val:" = None"},{name:"qualname",val:" = None"},{name:"type",val:" = None"},{name:"start",val:" = 1"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L754"}}),Qt=new x({props:{name:"class accelerate.utils.SageMakerDistributedType",anchor:"accelerate.utils.SageMakerDistributedType",parameters:[{name:"value",val:""},{name:"names",val:" = None"},{name:"module",val:" = None"},{name:"qualname",val:" = None"},{name:"type",val:" = None"},{name:"start",val:" = 1"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L605"}}),Kt=new M({props:{title:"Kwargs",local:"accelerate.AutocastKwargs",headingTag:"h3"}}),ta=new x({props:{name:"class accelerate.AutocastKwargs",anchor:"accelerate.AutocastKwargs",parameters:[{name:"enabled",val:": bool = True"},{name:"cache_enabled",val:": typing.Optional[bool] = None"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L112"}}),st=new rt({props:{anchor:"accelerate.AutocastKwargs.example",$$slots:{default:[tg]},$$scope:{ctx:k}}}),aa=new x({props:{name:"class accelerate.DistributedDataParallelKwargs",anchor:"accelerate.DistributedDataParallelKwargs",parameters:[{name:"dim",val:": int = 0"},{name:"broadcast_buffers",val:": bool = True"},{name:"bucket_cap_mb",val:": int = 25"},{name:"find_unused_parameters",val:": bool = False"},{name:"check_reduction",val:": bool = False"},{name:"gradient_as_bucket_view",val:": bool = False"},{name:"static_graph",val:": bool = False"},{name:"comm_hook",val:": DDPCommunicationHookType = <DDPCommunicationHookType.NO: 'no'>"},{name:"comm_wrapper",val:": typing.Literal[<DDPCommunicationHookType.NO: 'no'>, <DDPCommunicationHookType.FP16: 'fp16'>, <DDPCommunicationHookType.BF16: 'bf16'>] = <DDPCommunicationHookType.NO: 'no'>"},{name:"comm_state_option",val:": dict = <factory>"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L154"}}),it=new an({props:{warning:!0,$$slots:{default:[ag]},$$scope:{ctx:k}}}),ct=new rt({props:{anchor:"accelerate.DistributedDataParallelKwargs.example",$$slots:{default:[og]},$$scope:{ctx:k}}}),oa=new x({props:{name:"class accelerate.utils.FP8RecipeKwargs",anchor:"accelerate.utils.FP8RecipeKwargs",parameters:[{name:"opt_level",val:": typing.Literal['O1', 'O2'] = None"},{name:"use_autocast_during_eval",val:": typing.Optional[bool] = None"},{name:"margin",val:": typing.Optional[int] = None"},{name:"interval",val:": typing.Optional[int] = None"},{name:"fp8_format",val:": typing.Literal['HYBRID', 'E4M3', 'E5M2'] = None"},{name:"amax_history_len",val:": typing.Optional[int] = None"},{name:"amax_compute_algo",val:": typing.Literal['max', 'most_recent'] = None"},{name:"override_linear_precision",val:": tuple = None"},{name:"use_mxfp8_block_scaling",val:": typing.Optional[bool] = None"},{name:"backend",val:": typing.Literal['MSAMP', 'TE'] = None"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L425"}}),na=new x({props:{name:"class accelerate.GradScalerKwargs",anchor:"accelerate.GradScalerKwargs",parameters:[{name:"init_scale",val:": float = 65536.0"},{name:"growth_factor",val:": float = 2.0"},{name:"backoff_factor",val:": float = 0.5"},{name:"growth_interval",val:": int = 2000"},{name:"enabled",val:": bool = True"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L240"}}),dt=new an({props:{warning:!0,$$slots:{default:[ng]},$$scope:{ctx:k}}}),pt=new rt({props:{anchor:"accelerate.GradScalerKwargs.example",$$slots:{default:[rg]},$$scope:{ctx:k}}}),ra=new x({props:{name:"class accelerate.InitProcessGroupKwargs",anchor:"accelerate.InitProcessGroupKwargs",parameters:[{name:"backend",val:": typing.Optional[str] = 'nccl'"},{name:"init_method",val:": typing.Optional[str] = None"},{name:"timeout",val:": typing.Optional[datetime.timedelta] = None"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L272"}}),mt=new rt({props:{anchor:"accelerate.InitProcessGroupKwargs.example",$$slots:{default:[lg]},$$scope:{ctx:k}}}),la=new x({props:{name:"class accelerate.utils.KwargsHandler",anchor:"accelerate.utils.KwargsHandler",parameters:[],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L67"}}),sa=new x({props:{name:"to_kwargs",anchor:"accelerate.utils.KwargsHandler.to_kwargs",parameters:[],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L75"}}),ia=new M({props:{title:"Plugins",local:"accelerate.DeepSpeedPlugin",headingTag:"h2"}}),da=new x({props:{name:"class accelerate.DeepSpeedPlugin",anchor:"accelerate.DeepSpeedPlugin",parameters:[{name:"hf_ds_config",val:": typing.Any = None"},{name:"gradient_accumulation_steps",val:": int = None"},{name:"gradient_clipping",val:": float = None"},{name:"zero_stage",val:": int = None"},{name:"is_train_batch_min",val:": bool = True"},{name:"offload_optimizer_device",val:": str = None"},{name:"offload_param_device",val:": str = None"},{name:"offload_optimizer_nvme_path",val:": str = None"},{name:"offload_param_nvme_path",val:": str = None"},{name:"zero3_init_flag",val:": bool = None"},{name:"zero3_save_16bit_model",val:": bool = None"},{name:"transformer_moe_cls_names",val:": str = None"},{name:"enable_msamp",val:": bool = None"},{name:"msamp_opt_level",val:": typing.Optional[typing.Literal['O1', 'O2']] = None"}],parametersDescription:[{anchor:"accelerate.DeepSpeedPlugin.hf_ds_config",description:`<strong>hf_ds_config</strong> (<code>Any</code>, defaults to <code>None</code>) &#x2014;
Path to DeepSpeed config file or dict or an object of class <code>accelerate.utils.deepspeed.HfDeepSpeedConfig</code>.`,name:"hf_ds_config"},{anchor:"accelerate.DeepSpeedPlugin.gradient_accumulation_steps",description:`<strong>gradient_accumulation_steps</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Number of steps to accumulate gradients before updating optimizer states. If not set, will use the value
from the <code>Accelerator</code> directly.`,name:"gradient_accumulation_steps"},{anchor:"accelerate.DeepSpeedPlugin.gradient_clipping",description:`<strong>gradient_clipping</strong> (<code>float</code>, defaults to <code>None</code>) &#x2014;
Enable gradient clipping with value.`,name:"gradient_clipping"},{anchor:"accelerate.DeepSpeedPlugin.zero_stage",description:`<strong>zero_stage</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Possible options are 0, 1, 2, 3. Default will be taken from environment variable.`,name:"zero_stage"},{anchor:"accelerate.DeepSpeedPlugin.is_train_batch_min",description:`<strong>is_train_batch_min</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
If both train &amp; eval dataloaders are specified, this will decide the <code>train_batch_size</code>.`,name:"is_train_batch_min"},{anchor:"accelerate.DeepSpeedPlugin.offload_optimizer_device",description:`<strong>offload_optimizer_device</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Possible options are none|cpu|nvme. Only applicable with ZeRO Stages 2 and 3.`,name:"offload_optimizer_device"},{anchor:"accelerate.DeepSpeedPlugin.offload_param_device",description:`<strong>offload_param_device</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Possible options are none|cpu|nvme. Only applicable with ZeRO Stage 3.`,name:"offload_param_device"},{anchor:"accelerate.DeepSpeedPlugin.offload_optimizer_nvme_path",description:`<strong>offload_optimizer_nvme_path</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Possible options are /nvme|/local_nvme. Only applicable with ZeRO Stage 3.`,name:"offload_optimizer_nvme_path"},{anchor:"accelerate.DeepSpeedPlugin.offload_param_nvme_path",description:`<strong>offload_param_nvme_path</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Possible options are /nvme|/local_nvme. Only applicable with ZeRO Stage 3.`,name:"offload_param_nvme_path"},{anchor:"accelerate.DeepSpeedPlugin.zero3_init_flag",description:`<strong>zero3_init_flag</strong> (<code>bool</code>, defaults to <code>None</code>) &#x2014;
Flag to indicate whether to save 16-bit model. Only applicable with ZeRO Stage-3.`,name:"zero3_init_flag"},{anchor:"accelerate.DeepSpeedPlugin.zero3_save_16bit_model",description:`<strong>zero3_save_16bit_model</strong> (<code>bool</code>, defaults to <code>None</code>) &#x2014;
Flag to indicate whether to save 16-bit model. Only applicable with ZeRO Stage-3.`,name:"zero3_save_16bit_model"},{anchor:"accelerate.DeepSpeedPlugin.transformer_moe_cls_names",description:`<strong>transformer_moe_cls_names</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Comma-separated list of Transformers MoE layer class names (case-sensitive). For example,
<code>MixtralSparseMoeBlock</code>, <code>Qwen2MoeSparseMoeBlock</code>, <code>JetMoEAttention</code>, <code>JetMoEBlock</code>, etc.`,name:"transformer_moe_cls_names"},{anchor:"accelerate.DeepSpeedPlugin.enable_msamp",description:`<strong>enable_msamp</strong> (<code>bool</code>, defaults to <code>None</code>) &#x2014;
Flag to indicate whether to enable MS-AMP backend for FP8 training.`,name:"enable_msamp"},{anchor:"accelerate.DeepSpeedPlugin.msasmp_opt_level",description:`<strong>msasmp_opt_level</strong> (<code>Optional[Literal[&quot;O1&quot;, &quot;O2&quot;]]</code>, defaults to <code>None</code>) &#x2014;
Optimization level for MS-AMP (defaults to &#x2018;O1&#x2019;). Only applicable if <code>enable_msamp</code> is True. Should be one
of [&#x2018;O1&#x2019; or &#x2018;O2&#x2019;].`,name:"msasmp_opt_level"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1086"}}),pa=new x({props:{name:"deepspeed_config_process",anchor:"accelerate.DeepSpeedPlugin.deepspeed_config_process",parameters:[{name:"prefix",val:" = ''"},{name:"mismatches",val:" = None"},{name:"config",val:" = None"},{name:"must_match",val:" = True"},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1355"}}),ma=new x({props:{name:"select",anchor:"accelerate.DeepSpeedPlugin.select",parameters:[{name:"_from_accelerator_state",val:": bool = False"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1506"}}),ua=new x({props:{name:"class accelerate.FullyShardedDataParallelPlugin",anchor:"accelerate.FullyShardedDataParallelPlugin",parameters:[{name:"fsdp_version",val:": int = None"},{name:"sharding_strategy",val:": typing.Union[str, ForwardRef('torch.distributed.fsdp.ShardingStrategy')] = None"},{name:"reshard_after_forward",val:": typing.Union[str, ForwardRef('torch.distributed.fsdp.ShardingStrategy'), bool] = None"},{name:"backward_prefetch",val:": typing.Union[str, ForwardRef('torch.distributed.fsdp.BackwardPrefetch'), NoneType] = None"},{name:"mixed_precision_policy",val:": typing.Union[dict, str, ForwardRef('torch.distributed.fsdp.MixedPrecision'), ForwardRef('torch.distributed.fsdp.MixedPrecisionPolicy'), NoneType] = None"},{name:"auto_wrap_policy",val:": typing.Union[typing.Callable, typing.Literal['transformer_based_wrap', 'size_based_wrap', 'no_wrap'], NoneType] = None"},{name:"cpu_offload",val:": typing.Union[bool, ForwardRef('torch.distributed.fsdp.CPUOffload'), ForwardRef('torch.distributed.fsdp.CPUOffloadPolicy')] = None"},{name:"ignored_modules",val:": typing.Union[collections.abc.Iterable[torch.nn.modules.module.Module], str, NoneType] = None"},{name:"state_dict_type",val:": typing.Union[str, ForwardRef('torch.distributed.fsdp.StateDictType')] = None"},{name:"state_dict_config",val:": typing.Union[ForwardRef('torch.distributed.fsdp.FullStateDictConfig'), ForwardRef('torch.distributed.fsdp.ShardedStateDictConfig'), NoneType] = None"},{name:"optim_state_dict_config",val:": typing.Union[ForwardRef('torch.distributed.fsdp.FullOptimStateDictConfig'), ForwardRef('torch.distributed.fsdp.ShardedOptimStateDictConfig'), NoneType] = None"},{name:"limit_all_gathers",val:": bool = True"},{name:"use_orig_params",val:": typing.Optional[bool] = None"},{name:"param_init_fn",val:": typing.Optional[typing.Callable[[torch.nn.modules.module.Module], NoneType]] = None"},{name:"sync_module_states",val:": typing.Optional[bool] = None"},{name:"forward_prefetch",val:": bool = None"},{name:"activation_checkpointing",val:": bool = None"},{name:"cpu_ram_efficient_loading",val:": bool = None"},{name:"transformer_cls_names_to_wrap",val:": typing.Optional[list[str]] = None"},{name:"min_num_params",val:": typing.Optional[int] = None"}],parametersDescription:[{anchor:"accelerate.FullyShardedDataParallelPlugin.fsdp_version",description:`<strong>fsdp_version</strong> (<code>int</code>, defaults to <code>1</code>) &#x2014;
The version of FSDP to use. Defaults to 1. If set to 2, launcher expects the config to be converted to
FSDP2 format.`,name:"fsdp_version"},{anchor:"accelerate.FullyShardedDataParallelPlugin.sharding_strategy",description:`<strong>sharding_strategy</strong> (<code>Union[str, torch.distributed.fsdp.ShardingStrategy]</code>, defaults to <code>&apos;FULL_SHARD&apos;</code>) &#x2014;
Sharding strategy to use. Should be either a <code>str</code> or an instance of
<code>torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy</code>. Is deprecated in favor of
<code>reshard_after_forward</code>.`,name:"sharding_strategy"},{anchor:"accelerate.FullyShardedDataParallelPlugin.reshard_after_forward",description:`<strong>reshard_after_forward</strong> (<code>Union[str, torch.distributed.fsdp.ShardingStrategy, bool]</code>, defaults to <code>&apos;FULL_SHARD&apos;</code> for <code>fsdp_version=1</code> and <code>True</code> for <code>fsdp_version=2</code>) &#x2014;
Sharding strategy to use. Should be a bool if <code>fsdp_version</code> is set to 2 else a <code>str</code> or an instance of
<code>torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy</code>.`,name:"reshard_after_forward"},{anchor:"accelerate.FullyShardedDataParallelPlugin.backward_prefetch",description:`<strong>backward_prefetch</strong> (<code>Union[str, torch.distributed.fsdp.BackwardPrefetch]</code>, defaults to <code>&apos;NO_PREFETCH&apos;</code>) &#x2014;
Backward prefetch strategy to use. Should be either a <code>str</code> or an instance of
<code>torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch</code>.`,name:"backward_prefetch"},{anchor:"accelerate.FullyShardedDataParallelPlugin.mixed_precision_policy",description:`<strong>mixed_precision_policy</strong> (<code>Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]]</code>, defaults to <code>None</code>) &#x2014;
A config to enable mixed precision training with FullyShardedDataParallel. If passing in a <code>dict</code>, it
should have the following keys: <code>param_dtype</code>, <code>reduce_dtype</code>, and <code>buffer_dtype</code>, can be an instance of
<code>torch.distributed.fsdp.MixedPrecisionPolicy</code> if <code>fsdp_version</code> is set to 2. If passing in a <code>str</code>, it
should be one of the following values: fp8, fp16, bf16, fp32, and used to set <code>param_dtype</code>,
<code>reduce_dtype</code>, and <code>buffer_dtype</code>.`,name:"mixed_precision_policy"},{anchor:"accelerate.FullyShardedDataParallelPlugin.auto_wrap_policy",description:"<strong>auto_wrap_policy</strong> (<code>Optional(Union[Callable, Literal[&quot;transformer_based_wrap&quot;, &quot;size_based_wrap&quot;, &quot;no_wrap&quot;]]), defaults to </code>NO_WRAP<code>) -- A callable or string specifying a policy to recursively wrap layers with FSDP. If a string, it must be one of </code>transformer_based_wrap<code>, </code>size_based_wrap<code>, or </code>no_wrap<code>. See </code>torch.distributed.fsdp.wrap.size_based_wrap_policy` for a direction on what it should look like.",name:"auto_wrap_policy"},{anchor:"accelerate.FullyShardedDataParallelPlugin.cpu_offload",description:`<strong>cpu_offload</strong> (<code>Union[bool, torch.distributed.fsdp.CPUOffload, torch.distributed.fsdp.CPUOffloadPolicy]</code>, defaults to <code>False</code>) &#x2014;
Whether to offload parameters to CPU. Should be either a <code>bool</code> or an instance of
<code>torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload</code> or
<code>torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy</code> if <code>fsdp_version</code> is set to 2.`,name:"cpu_offload"},{anchor:"accelerate.FullyShardedDataParallelPlugin.ignored_modules",description:`<strong>ignored_modules</strong> (<code>Optional[Union[Iterable[torch.nn.Module], str]]</code>, defaults to <code>None</code>) &#x2014;
A list of modules to ignore when wrapping with FSDP. When passing a string, will match the modules by name
using regex fullmatch. If <code>fsdp_version</code> is set to 2, the modules are converted to parameters and used.`,name:"ignored_modules"},{anchor:"accelerate.FullyShardedDataParallelPlugin.state_dict_type",description:`<strong>state_dict_type</strong> (<code>Union[str, torch.distributed.fsdp.StateDictType]</code>, defaults to <code>&apos;FULL_STATE_DICT&apos;</code>) &#x2014;
State dict type to use. If a string, it must be one of <code>full_state_dict</code>, <code>local_state_dict</code>, or
<code>sharded_state_dict</code>.`,name:"state_dict_type"},{anchor:"accelerate.FullyShardedDataParallelPlugin.state_dict_config",description:`<strong>state_dict_config</strong> (<code>Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig]</code>, defaults to <code>None</code>) &#x2014;
State dict config to use. Is determined based on the <code>state_dict_type</code> if not passed in.`,name:"state_dict_config"},{anchor:"accelerate.FullyShardedDataParallelPlugin.optim_state_dict_config",description:`<strong>optim_state_dict_config</strong> (<code>Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig]</code>, defaults to <code>None</code>) &#x2014;
Optim state dict config to use. Is determined based on the <code>state_dict_type</code> if not passed in.`,name:"optim_state_dict_config"},{anchor:"accelerate.FullyShardedDataParallelPlugin.limit_all_gathers",description:`<strong>limit_all_gathers</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
Whether to have FSDP explicitly synchronizes the CPU thread to prevent too many in-flight all-gathers. This
bool only affects the sharded strategies that schedule all-gathers. Enabling this can help lower the number
of CUDA malloc retries.`,name:"limit_all_gathers"},{anchor:"accelerate.FullyShardedDataParallelPlugin.use_orig_params",description:`<strong>use_orig_params</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Whether to use the original parameters for the optimizer.`,name:"use_orig_params"},{anchor:"accelerate.FullyShardedDataParallelPlugin.param_init_fn",description:`<strong>param_init_fn</strong> (<code>Optional[Callable[[torch.nn.Module], None]</code>, defaults to <code>None</code>) &#x2014;
A <code>Callable[torch.nn.Module] -&gt; None</code> that specifies how modules that are currently on the meta device
should be initialized onto an actual device. Only applicable when <code>sync_module_states</code> is <code>True</code>. By
default is a <code>lambda</code> which calls <code>to_empty</code> on the module.`,name:"param_init_fn"},{anchor:"accelerate.FullyShardedDataParallelPlugin.sync_module_states",description:`<strong>sync_module_states</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Whether each individually wrapped FSDP unit should broadcast module parameters from rank 0 to ensure they
are the same across all ranks after initialization. Defaults to <code>False</code> unless <code>cpu_ram_efficient_loading</code>
is <code>True</code>, then will be forcibly enabled.`,name:"sync_module_states"},{anchor:"accelerate.FullyShardedDataParallelPlugin.forward_prefetch",description:`<strong>forward_prefetch</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Whether to have FSDP explicitly prefetches the next upcoming all-gather while executing in the forward
pass. only use with Static graphs.`,name:"forward_prefetch"},{anchor:"accelerate.FullyShardedDataParallelPlugin.activation_checkpointing",description:`<strong>activation_checkpointing</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
A technique to reduce memory usage by clearing activations of certain layers and recomputing them during a
backward pass. Effectively, this trades extra computation time for reduced memory usage.`,name:"activation_checkpointing"},{anchor:"accelerate.FullyShardedDataParallelPlugin.cpu_ram_efficient_loading",description:`<strong>cpu_ram_efficient_loading</strong> (<code>bool</code>, defaults to <code>None</code>) &#x2014;
If True, only the first process loads the pretrained model checkoint while all other processes have empty
weights. Only applicable for Transformers. When using this, <code>sync_module_states</code> needs to be <code>True</code>.`,name:"cpu_ram_efficient_loading"},{anchor:"accelerate.FullyShardedDataParallelPlugin.transformer_cls_names_to_wrap",description:`<strong>transformer_cls_names_to_wrap</strong> (<code>Optional[List[str]]</code>, defaults to <code>None</code>) &#x2014;
A list of transformer layer class names to wrap. Only applicable when <code>auto_wrap_policy</code> is
<code>transformer_based_wrap</code>.`,name:"transformer_cls_names_to_wrap"},{anchor:"accelerate.FullyShardedDataParallelPlugin.min_num_params",description:`<strong>min_num_params</strong> (<code>Optional[int]</code>, defaults to <code>None</code>) &#x2014;
The minimum number of parameters a module must have to be wrapped. Only applicable when <code>auto_wrap_policy</code>
is <code>size_based_wrap</code>.`,name:"min_num_params"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1538"}}),ga=new x({props:{name:"set_auto_wrap_policy",anchor:"accelerate.FullyShardedDataParallelPlugin.set_auto_wrap_policy",parameters:[{name:"model",val:""}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L2016"}}),ha=new x({props:{name:"set_mixed_precision",anchor:"accelerate.FullyShardedDataParallelPlugin.set_mixed_precision",parameters:[{name:"mixed_precision",val:""},{name:"buffer_autocast",val:" = False"},{name:"override",val:" = False"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L2050"}}),fa=new x({props:{name:"set_state_dict_type",anchor:"accelerate.FullyShardedDataParallelPlugin.set_state_dict_type",parameters:[{name:"state_dict_type",val:" = None"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1971"}}),_a=new x({props:{name:"validate_mixed_precision_policy",anchor:"accelerate.FullyShardedDataParallelPlugin.validate_mixed_precision_policy",parameters:[],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L2102"}}),ba=new x({props:{name:"class accelerate.utils.GradientAccumulationPlugin",anchor:"accelerate.utils.GradientAccumulationPlugin",parameters:[{name:"num_steps",val:": int = None"},{name:"adjust_scheduler",val:": bool = True"},{name:"sync_with_dataloader",val:": bool = True"},{name:"sync_each_batch",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.utils.GradientAccumulationPlugin.num_steps",description:`<strong>num_steps</strong> (<code>int</code>) &#x2014;
The number of steps to accumulate gradients for.`,name:"num_steps"},{anchor:"accelerate.utils.GradientAccumulationPlugin.adjust_scheduler",description:`<strong>adjust_scheduler</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether to adjust the scheduler steps to account for the number of steps being accumulated. Should be
<code>True</code> if the used scheduler was not adjusted for gradient accumulation.`,name:"adjust_scheduler"},{anchor:"accelerate.utils.GradientAccumulationPlugin.sync_with_dataloader",description:`<strong>sync_with_dataloader</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether to synchronize setting the gradients when at the end of the dataloader.`,name:"sync_with_dataloader"},{anchor:"accelerate.utils.GradientAccumulationPlugin.sync_each_batch",description:`<strong>sync_each_batch</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether to synchronize setting the gradients at each data batch. Setting to <code>True</code> may reduce memory
requirements when using gradient accumulation with distributed training, at expense of speed.`,name:"sync_each_batch"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L945"}}),yt=new rt({props:{anchor:"accelerate.utils.GradientAccumulationPlugin.example",$$slots:{default:[sg]},$$scope:{ctx:k}}}),va=new x({props:{name:"class accelerate.utils.MegatronLMPlugin",anchor:"accelerate.utils.MegatronLMPlugin",parameters:[{name:"tp_degree",val:": int = None"},{name:"pp_degree",val:": int = None"},{name:"num_micro_batches",val:": int = None"},{name:"gradient_clipping",val:": float = None"},{name:"sequence_parallelism",val:": bool = None"},{name:"recompute_activations",val:": bool = None"},{name:"use_distributed_optimizer",val:": bool = None"},{name:"pipeline_model_parallel_split_rank",val:": int = None"},{name:"num_layers_per_virtual_pipeline_stage",val:": int = None"},{name:"is_train_batch_min",val:": str = True"},{name:"train_iters",val:": int = None"},{name:"train_samples",val:": int = None"},{name:"weight_decay_incr_style",val:": str = 'constant'"},{name:"start_weight_decay",val:": float = None"},{name:"end_weight_decay",val:": float = None"},{name:"lr_decay_style",val:": str = 'linear'"},{name:"lr_decay_iters",val:": int = None"},{name:"lr_decay_samples",val:": int = None"},{name:"lr_warmup_iters",val:": int = None"},{name:"lr_warmup_samples",val:": int = None"},{name:"lr_warmup_fraction",val:": float = None"},{name:"min_lr",val:": float = 0"},{name:"consumed_samples",val:": list = None"},{name:"no_wd_decay_cond",val:": typing.Optional[typing.Callable] = None"},{name:"scale_lr_cond",val:": typing.Optional[typing.Callable] = None"},{name:"lr_mult",val:": float = 1.0"},{name:"megatron_dataset_flag",val:": bool = False"},{name:"seq_length",val:": int = None"},{name:"encoder_seq_length",val:": int = None"},{name:"decoder_seq_length",val:": int = None"},{name:"tensorboard_dir",val:": str = None"},{name:"set_all_logging_options",val:": bool = False"},{name:"eval_iters",val:": int = 100"},{name:"eval_interval",val:": int = 1000"},{name:"return_logits",val:": bool = False"},{name:"custom_train_step_class",val:": typing.Optional[typing.Any] = None"},{name:"custom_train_step_kwargs",val:": typing.Optional[dict[str, typing.Any]] = None"},{name:"custom_model_provider_function",val:": typing.Optional[typing.Callable] = None"},{name:"custom_prepare_model_function",val:": typing.Optional[typing.Callable] = None"},{name:"custom_megatron_datasets_provider_function",val:": typing.Optional[typing.Callable] = None"},{name:"custom_get_batch_function",val:": typing.Optional[typing.Callable] = None"},{name:"custom_loss_function",val:": typing.Optional[typing.Callable] = None"},{name:"other_megatron_args",val:": typing.Optional[dict[str, typing.Any]] = None"}],parametersDescription:[{anchor:"accelerate.utils.MegatronLMPlugin.tp_degree",description:`<strong>tp_degree</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Tensor parallelism degree.`,name:"tp_degree"},{anchor:"accelerate.utils.MegatronLMPlugin.pp_degree",description:`<strong>pp_degree</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Pipeline parallelism degree.`,name:"pp_degree"},{anchor:"accelerate.utils.MegatronLMPlugin.num_micro_batches",description:`<strong>num_micro_batches</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Number of micro-batches.`,name:"num_micro_batches"},{anchor:"accelerate.utils.MegatronLMPlugin.gradient_clipping",description:`<strong>gradient_clipping</strong> (<code>float</code>, defaults to <code>None</code>) &#x2014;
Gradient clipping value based on global L2 Norm (0 to disable).`,name:"gradient_clipping"},{anchor:"accelerate.utils.MegatronLMPlugin.sequence_parallelism",description:`<strong>sequence_parallelism</strong> (<code>bool</code>, defaults to <code>None</code>) &#x2014;
Enable sequence parallelism.`,name:"sequence_parallelism"},{anchor:"accelerate.utils.MegatronLMPlugin.recompute_activations",description:`<strong>recompute_activations</strong> (<code>bool</code>, defaults to <code>None</code>) &#x2014;
Enable selective activation recomputation.`,name:"recompute_activations"},{anchor:"accelerate.utils.MegatronLMPlugin.use_distributed_optimizr",description:`<strong>use_distributed_optimizr</strong> (<code>bool</code>, defaults to <code>None</code>) &#x2014;
Enable distributed optimizer.`,name:"use_distributed_optimizr"},{anchor:"accelerate.utils.MegatronLMPlugin.pipeline_model_parallel_split_rank",description:`<strong>pipeline_model_parallel_split_rank</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Rank where encoder and decoder should be split.`,name:"pipeline_model_parallel_split_rank"},{anchor:"accelerate.utils.MegatronLMPlugin.num_layers_per_virtual_pipeline_stage",description:`<strong>num_layers_per_virtual_pipeline_stage</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Number of layers per virtual pipeline stage.`,name:"num_layers_per_virtual_pipeline_stage"},{anchor:"accelerate.utils.MegatronLMPlugin.is_train_batch_min",description:`<strong>is_train_batch_min</strong> (<code>str</code>, defaults to <code>True</code>) &#x2014;
If both tran &amp; eval dataloaders are specified, this will decide the <code>micro_batch_size</code>.`,name:"is_train_batch_min"},{anchor:"accelerate.utils.MegatronLMPlugin.train_iters",description:`<strong>train_iters</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Total number of samples to train over all training runs. Note that either train-iters or train-samples
should be provided when using <code>MegatronLMDummyScheduler</code>.`,name:"train_iters"},{anchor:"accelerate.utils.MegatronLMPlugin.train_samples",description:`<strong>train_samples</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Total number of samples to train over all training runs. Note that either train-iters or train-samples
should be provided when using <code>MegatronLMDummyScheduler</code>.`,name:"train_samples"},{anchor:"accelerate.utils.MegatronLMPlugin.weight_decay_incr_style",description:`<strong>weight_decay_incr_style</strong> (<code>str</code>, defaults to <code>&apos;constant&apos;</code>) &#x2014;
Weight decay increment function. choices=[&#x201C;constant&#x201D;, &#x201C;linear&#x201D;, &#x201C;cosine&#x201D;].`,name:"weight_decay_incr_style"},{anchor:"accelerate.utils.MegatronLMPlugin.start_weight_decay",description:`<strong>start_weight_decay</strong> (<code>float</code>, defaults to <code>None</code>) &#x2014;
Initial weight decay coefficient for L2 regularization.`,name:"start_weight_decay"},{anchor:"accelerate.utils.MegatronLMPlugin.end_weight_decay",description:`<strong>end_weight_decay</strong> (<code>float</code>, defaults to <code>None</code>) &#x2014;
End of run weight decay coefficient for L2 regularization.`,name:"end_weight_decay"},{anchor:"accelerate.utils.MegatronLMPlugin.lr_decay_style",description:`<strong>lr_decay_style</strong> (<code>str</code>, defaults to <code>&apos;linear&apos;</code>) &#x2014;
Learning rate decay function. choices=[&#x2018;constant&#x2019;, &#x2018;linear&#x2019;, &#x2018;cosine&#x2019;].`,name:"lr_decay_style"},{anchor:"accelerate.utils.MegatronLMPlugin.lr_decay_iters",description:`<strong>lr_decay_iters</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Number of iterations for learning rate decay. If None defaults to <code>train_iters</code>.`,name:"lr_decay_iters"},{anchor:"accelerate.utils.MegatronLMPlugin.lr_decay_samples",description:`<strong>lr_decay_samples</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Number of samples for learning rate decay. If None defaults to <code>train_samples</code>.`,name:"lr_decay_samples"},{anchor:"accelerate.utils.MegatronLMPlugin.lr_warmup_iters",description:`<strong>lr_warmup_iters</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Number of iterations to linearly warmup learning rate over.`,name:"lr_warmup_iters"},{anchor:"accelerate.utils.MegatronLMPlugin.lr_warmup_samples",description:`<strong>lr_warmup_samples</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Number of samples to linearly warmup learning rate over.`,name:"lr_warmup_samples"},{anchor:"accelerate.utils.MegatronLMPlugin.lr_warmup_fraction",description:`<strong>lr_warmup_fraction</strong> (<code>float</code>, defaults to <code>None</code>) &#x2014;
Fraction of lr-warmup-(iters/samples) to linearly warmup learning rate over.`,name:"lr_warmup_fraction"},{anchor:"accelerate.utils.MegatronLMPlugin.min_lr",description:`<strong>min_lr</strong> (<code>float</code>, defaults to <code>0</code>) &#x2014;
Minimum value for learning rate. The scheduler clip values below this threshold.`,name:"min_lr"},{anchor:"accelerate.utils.MegatronLMPlugin.consumed_samples",description:`<strong>consumed_samples</strong> (<code>List</code>, defaults to <code>None</code>) &#x2014;
Number of samples consumed in the same order as the dataloaders to <code>accelerator.prepare</code> call.`,name:"consumed_samples"},{anchor:"accelerate.utils.MegatronLMPlugin.no_wd_decay_cond",description:`<strong>no_wd_decay_cond</strong> (<code>Optional</code>, defaults to <code>None</code>) &#x2014;
Condition to disable weight decay.`,name:"no_wd_decay_cond"},{anchor:"accelerate.utils.MegatronLMPlugin.scale_lr_cond",description:`<strong>scale_lr_cond</strong> (<code>Optional</code>, defaults to <code>None</code>) &#x2014;
Condition to scale learning rate.`,name:"scale_lr_cond"},{anchor:"accelerate.utils.MegatronLMPlugin.lr_mult",description:`<strong>lr_mult</strong> (<code>float</code>, defaults to <code>1.0</code>) &#x2014;
Learning rate multiplier.`,name:"lr_mult"},{anchor:"accelerate.utils.MegatronLMPlugin.megatron_dataset_flag",description:`<strong>megatron_dataset_flag</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Whether the format of dataset follows Megatron-LM Indexed/Cached/MemoryMapped format.`,name:"megatron_dataset_flag"},{anchor:"accelerate.utils.MegatronLMPlugin.seq_length",description:`<strong>seq_length</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Maximum sequence length to process.`,name:"seq_length"},{anchor:"accelerate.utils.MegatronLMPlugin.encoder_seq_length",description:`<strong>encoder_seq_length</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Maximum sequence length to process for the encoder.`,name:"encoder_seq_length"},{anchor:"accelerate.utils.MegatronLMPlugin.decoder_seq_length",description:`<strong>decoder_seq_length</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Maximum sequence length to process for the decoder.`,name:"decoder_seq_length"},{anchor:"accelerate.utils.MegatronLMPlugin.tensorboard_dir",description:`<strong>tensorboard_dir</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Path to save tensorboard logs.`,name:"tensorboard_dir"},{anchor:"accelerate.utils.MegatronLMPlugin.set_all_logging_options",description:`<strong>set_all_logging_options</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Whether to set all logging options.`,name:"set_all_logging_options"},{anchor:"accelerate.utils.MegatronLMPlugin.eval_iters",description:`<strong>eval_iters</strong> (<code>int</code>, defaults to <code>100</code>) &#x2014;
Number of iterations to run for evaluation validation/test for.`,name:"eval_iters"},{anchor:"accelerate.utils.MegatronLMPlugin.eval_interval",description:`<strong>eval_interval</strong> (<code>int</code>, defaults to <code>1000</code>) &#x2014;
Interval between running evaluation on validation set.`,name:"eval_interval"},{anchor:"accelerate.utils.MegatronLMPlugin.return_logits",description:`<strong>return_logits</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Whether to return logits from the model.`,name:"return_logits"},{anchor:"accelerate.utils.MegatronLMPlugin.custom_train_step_class",description:`<strong>custom_train_step_class</strong> (<code>Optional</code>, defaults to <code>None</code>) &#x2014;
Custom train step class.`,name:"custom_train_step_class"},{anchor:"accelerate.utils.MegatronLMPlugin.custom_train_step_kwargs",description:`<strong>custom_train_step_kwargs</strong> (<code>Optional</code>, defaults to <code>None</code>) &#x2014;
Custom train step kwargs.`,name:"custom_train_step_kwargs"},{anchor:"accelerate.utils.MegatronLMPlugin.custom_model_provider_function",description:`<strong>custom_model_provider_function</strong> (<code>Optional</code>, defaults to <code>None</code>) &#x2014;
Custom model provider function.`,name:"custom_model_provider_function"},{anchor:"accelerate.utils.MegatronLMPlugin.custom_prepare_model_function",description:`<strong>custom_prepare_model_function</strong> (<code>Optional</code>, defaults to <code>None</code>) &#x2014;
Custom prepare model function.`,name:"custom_prepare_model_function"},{anchor:"accelerate.utils.MegatronLMPlugin.custom_megatron_datasets_provider_function",description:`<strong>custom_megatron_datasets_provider_function</strong> (<code>Optional</code>, defaults to <code>None</code>) &#x2014;
Custom megatron train_valid_test datasets provider function.`,name:"custom_megatron_datasets_provider_function"},{anchor:"accelerate.utils.MegatronLMPlugin.custom_get_batch_function",description:`<strong>custom_get_batch_function</strong> (<code>Optional</code>, defaults to <code>None</code>) &#x2014;
Custom get batch function.`,name:"custom_get_batch_function"},{anchor:"accelerate.utils.MegatronLMPlugin.custom_loss_function",description:`<strong>custom_loss_function</strong> (<code>Optional</code>, defaults to <code>None</code>) &#x2014;
Custom loss function.`,name:"custom_loss_function"},{anchor:"accelerate.utils.MegatronLMPlugin.other_megatron_args",description:`<strong>other_megatron_args</strong> (<code>Optional</code>, defaults to <code>None</code>) &#x2014;
Other Megatron-LM arguments. Please refer Megatron-LM.`,name:"other_megatron_args"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L2215"}}),ya=new x({props:{name:"class accelerate.utils.TorchDynamoPlugin",anchor:"accelerate.utils.TorchDynamoPlugin",parameters:[{name:"backend",val:": DynamoBackend = None"},{name:"mode",val:": str = None"},{name:"fullgraph",val:": bool = None"},{name:"dynamic",val:": bool = None"},{name:"options",val:": typing.Any = None"},{name:"disable",val:": bool = False"},{name:"use_regional_compilation",val:": bool = None"}],parametersDescription:[{anchor:"accelerate.utils.TorchDynamoPlugin.backend",description:`<strong>backend</strong> (<code>DynamoBackend</code>, defaults to <code>None</code>) &#x2014;
A valid Dynamo backend. See <a href="https://pytorch.org/docs/stable/torch.compiler.html" rel="nofollow">https://pytorch.org/docs/stable/torch.compiler.html</a> for more details.`,name:"backend"},{anchor:"accelerate.utils.TorchDynamoPlugin.mode",description:`<strong>mode</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Possible options are &#x2018;default&#x2019;, &#x2018;reduce-overhead&#x2019; or &#x2018;max-autotune&#x2019;.`,name:"mode"},{anchor:"accelerate.utils.TorchDynamoPlugin.fullgraph",description:`<strong>fullgraph</strong> (<code>bool</code>, defaults to <code>None</code>) &#x2014;
Whether it is ok to break model into several subgraphs.`,name:"fullgraph"},{anchor:"accelerate.utils.TorchDynamoPlugin.dynamic",description:`<strong>dynamic</strong> (<code>bool</code>, defaults to <code>None</code>) &#x2014;
Whether to use dynamic shape for tracing.`,name:"dynamic"},{anchor:"accelerate.utils.TorchDynamoPlugin.options",description:`<strong>options</strong> (<code>Any</code>, defaults to <code>None</code>) &#x2014;
A dictionary of options to pass to the backend.`,name:"options"},{anchor:"accelerate.utils.TorchDynamoPlugin.disable",description:`<strong>disable</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Turn torch.compile() into a no-op for testing`,name:"disable"},{anchor:"accelerate.utils.TorchDynamoPlugin.use_regional_compilation",description:`<strong>use_regional_compilation</strong> (<code>bool</code>, defaults to <code>None</code>) &#x2014;
Use it to reduce the cold start compilation time of torch.compile() by targeting repeated blocks of the
same class and compiling them sequentially to hit the compiler&#x2019;s cache. For example, in <code>GPT2LMHeadModel</code>,
the repeated block/class is <code>GPT2Block</code>, and can be accessed as <code>model.transformer.h[0]</code>. The rest of the
model (e.g model.lm_head) is compiled separately.`,name:"use_regional_compilation"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L997"}}),$a=new M({props:{title:"Configurations",local:"accelerate.utils.BnbQuantizationConfig",headingTag:"h2"}}),wa=new x({props:{name:"class accelerate.utils.BnbQuantizationConfig",anchor:"accelerate.utils.BnbQuantizationConfig",parameters:[{name:"load_in_8bit",val:": bool = False"},{name:"llm_int8_threshold",val:": float = 6.0"},{name:"load_in_4bit",val:": bool = False"},{name:"bnb_4bit_quant_type",val:": str = 'fp4'"},{name:"bnb_4bit_use_double_quant",val:": bool = False"},{name:"bnb_4bit_compute_dtype",val:": str = 'fp16'"},{name:"torch_dtype",val:": dtype = None"},{name:"skip_modules",val:": list = None"},{name:"keep_in_fp32_modules",val:": list = None"}],parametersDescription:[{anchor:"accelerate.utils.BnbQuantizationConfig.load_in_8bit",description:`<strong>load_in_8bit</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Enable 8bit quantization.`,name:"load_in_8bit"},{anchor:"accelerate.utils.BnbQuantizationConfig.llm_int8_threshold",description:`<strong>llm_int8_threshold</strong> (<code>float</code>, defaults to <code>6.0</code>) &#x2014;
Value of the outliner threshold. Only relevant when <code>load_in_8bit=True</code>.`,name:"llm_int8_threshold"},{anchor:"accelerate.utils.BnbQuantizationConfig.load_in_4_bit",description:`<strong>load_in_4_bit</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Enable 4bit quantization.`,name:"load_in_4_bit"},{anchor:"accelerate.utils.BnbQuantizationConfig.bnb_4bit_quant_type",description:`<strong>bnb_4bit_quant_type</strong> (<code>str</code>, defaults to <code>fp4</code>) &#x2014;
Set the quantization data type in the <code>bnb.nn.Linear4Bit</code> layers. Options are {&#x2018;fp4&#x2019;,&#x2018;np4&#x2019;}.`,name:"bnb_4bit_quant_type"},{anchor:"accelerate.utils.BnbQuantizationConfig.bnb_4bit_use_double_quant",description:`<strong>bnb_4bit_use_double_quant</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Enable nested quantization where the quantization constants from the first quantization are quantized
again.`,name:"bnb_4bit_use_double_quant"},{anchor:"accelerate.utils.BnbQuantizationConfig.bnb_4bit_compute_dtype",description:`<strong>bnb_4bit_compute_dtype</strong> (<code>bool</code>, defaults to <code>fp16</code>) &#x2014;
This sets the computational type which might be different than the input time. For example, inputs might be
fp32, but computation can be set to bf16 for speedups. Options are {&#x2018;fp32&#x2019;,&#x2018;fp16&#x2019;,&#x2018;bf16&#x2019;}.`,name:"bnb_4bit_compute_dtype"},{anchor:"accelerate.utils.BnbQuantizationConfig.torch_dtype",description:`<strong>torch_dtype</strong> (<code>torch.dtype</code>, defaults to <code>None</code>) &#x2014;
This sets the dtype of the remaining non quantized layers. <code>bitsandbytes</code> library suggests to set the value
to <code>torch.float16</code> for 8 bit model and use the same dtype as the compute dtype for 4 bit model.`,name:"torch_dtype"},{anchor:"accelerate.utils.BnbQuantizationConfig.skip_modules",description:`<strong>skip_modules</strong> (<code>List[str]</code>, defaults to <code>None</code>) &#x2014;
An explicit list of the modules that we don&#x2019;t quantize. The dtype of these modules will be <code>torch_dtype</code>.`,name:"skip_modules"},{anchor:"accelerate.utils.BnbQuantizationConfig.keep_in_fp32_modules",description:`<strong>keep_in_fp32_modules</strong> (<code>List</code>, defaults to <code>None</code>) &#x2014;
An explicit list of the modules that we don&#x2019;t quantize. We keep them in <code>torch.float32</code>.`,name:"keep_in_fp32_modules"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L2770"}}),Ca=new x({props:{name:"class accelerate.DataLoaderConfiguration",anchor:"accelerate.DataLoaderConfiguration",parameters:[{name:"split_batches",val:": bool = False"},{name:"dispatch_batches",val:": bool = None"},{name:"even_batches",val:": bool = True"},{name:"use_seedable_sampler",val:": bool = False"},{name:"data_seed",val:": int = None"},{name:"non_blocking",val:": bool = False"},{name:"use_stateful_dataloader",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.DataLoaderConfiguration.split_batches",description:`<strong>split_batches</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Whether or not the accelerator should split the batches yielded by the dataloaders across the devices. If
<code>True</code>, the actual batch size used will be the same on any kind of distributed processes, but it must be a
round multiple of <code>num_processes</code> you are using. If <code>False</code>, actual batch size used will be the one set in
your script multiplied by the number of processes.`,name:"split_batches"},{anchor:"accelerate.DataLoaderConfiguration.dispatch_batches",description:`<strong>dispatch_batches</strong> (<code>bool</code>, defaults to <code>None</code>) &#x2014;
If set to <code>True</code>, the dataloader prepared by the Accelerator is only iterated through on the main process
and then the batches are split and broadcast to each process. Will default to <code>True</code> for <code>DataLoader</code> whose
underlying dataset is an <code>IterableDataset</code>, <code>False</code> otherwise.`,name:"dispatch_batches"},{anchor:"accelerate.DataLoaderConfiguration.even_batches",description:`<strong>even_batches</strong> (<code>bool</code>, defaults to <code>True</code>) &#x2014;
If set to <code>True</code>, in cases where the total batch size across all processes does not exactly divide the
dataset, samples at the start of the dataset will be duplicated so the batch can be divided equally among
all workers.`,name:"even_batches"},{anchor:"accelerate.DataLoaderConfiguration.use_seedable_sampler",description:`<strong>use_seedable_sampler</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Whether or not use a fully seedable random sampler (<code>data_loader.SeedableRandomSampler</code>). Ensures
training results are fully reproducible using a different sampling technique. While seed-to-seed results
may differ, on average the differences are negligible when using multiple different seeds to compare.
Should also be ran with <a href="/docs/accelerate/main/en/package_reference/utilities#accelerate.utils.set_seed">set_seed()</a> for the best results.`,name:"use_seedable_sampler"},{anchor:"accelerate.DataLoaderConfiguration.data_seed",description:`<strong>data_seed</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
The seed to use for the underlying generator when using <code>use_seedable_sampler</code>. If <code>None</code>, the generator
will use the current default seed from torch.`,name:"data_seed"},{anchor:"accelerate.DataLoaderConfiguration.non_blocking",description:`<strong>non_blocking</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If set to <code>True</code>, the dataloader prepared by the Accelerator will utilize non-blocking host-to-device
transfers, allowing for better overlap between dataloader communication and computation. Recommended that
the prepared dataloader has <code>pin_memory</code> set to <code>True</code> to work properly.`,name:"non_blocking"},{anchor:"accelerate.DataLoaderConfiguration.use_stateful_dataloader",description:`<strong>use_stateful_dataloader</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
If set to <code>True</code>, the dataloader prepared by the Accelerator will be backed by
<a href="https://github.com/pytorch/data/tree/main/torchdata/stateful_dataloader" rel="nofollow">torchdata.StatefulDataLoader</a>.
This requires <code>torchdata</code> version 0.8.0 or higher that supports StatefulDataLoader to be installed.`,name:"use_stateful_dataloader"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L787"}}),Ta=new x({props:{name:"class accelerate.utils.ProjectConfiguration",anchor:"accelerate.utils.ProjectConfiguration",parameters:[{name:"project_dir",val:": str = None"},{name:"logging_dir",val:": str = None"},{name:"automatic_checkpoint_naming",val:": bool = False"},{name:"total_limit",val:": int = None"},{name:"iteration",val:": int = 0"},{name:"save_on_each_node",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.utils.ProjectConfiguration.project_dir",description:`<strong>project_dir</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
A path to a directory for storing data.`,name:"project_dir"},{anchor:"accelerate.utils.ProjectConfiguration.logging_dir",description:`<strong>logging_dir</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
A path to a directory for storing logs of locally-compatible loggers. If None, defaults to <code>project_dir</code>.`,name:"logging_dir"},{anchor:"accelerate.utils.ProjectConfiguration.automatic_checkpoint_naming",description:`<strong>automatic_checkpoint_naming</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
Whether saved states should be automatically iteratively named.`,name:"automatic_checkpoint_naming"},{anchor:"accelerate.utils.ProjectConfiguration.total_limit",description:`<strong>total_limit</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
The maximum number of total saved states to keep.`,name:"total_limit"},{anchor:"accelerate.utils.ProjectConfiguration.iteration",description:`<strong>iteration</strong> (<code>int</code>, defaults to <code>0</code>) &#x2014;
The current save iteration.`,name:"iteration"},{anchor:"accelerate.utils.ProjectConfiguration.save_on_each_node",description:`<strong>save_on_each_node</strong> (<code>bool</code>, defaults to <code>False</code>) &#x2014;
When doing multi-node distributed training, whether to save models and checkpoints on each node, or only on
the main one.`,name:"save_on_each_node"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L882"}}),ka=new x({props:{name:"set_directories",anchor:"accelerate.utils.ProjectConfiguration.set_directories",parameters:[{name:"project_dir",val:": typing.Optional[str] = None"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L934"}}),Pa=new M({props:{title:"Environmental Variables",local:"environmental-variables",headingTag:"h2"}}),Na=new M({props:{title:"Data Manipulation and Operations",local:"accelerate.utils.broadcast",headingTag:"h2"}}),Ua=new x({props:{name:"accelerate.utils.broadcast",anchor:"accelerate.utils.broadcast",parameters:[{name:"tensor",val:""},{name:"from_process",val:": int = 0"}],parametersDescription:[{anchor:"accelerate.utils.broadcast.tensor",description:`<strong>tensor</strong> (nested list/tuple/dictionary of <code>torch.Tensor</code>) &#x2014;
The data to gather.`,name:"tensor"},{anchor:"accelerate.utils.broadcast.from_process",description:`<strong>from_process</strong> (<code>int</code>, <em>optional</em>, defaults to 0) &#x2014;
The process from which to send the data`,name:"from_process"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L538",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The same data structure as <code>tensor</code> with all tensors broadcasted to the proper device.</p>
`}}),ja=new x({props:{name:"accelerate.utils.broadcast_object_list",anchor:"accelerate.utils.broadcast_object_list",parameters:[{name:"object_list",val:""},{name:"from_process",val:": int = 0"}],parametersDescription:[{anchor:"accelerate.utils.broadcast_object_list.object_list",description:`<strong>object_list</strong> (list of picklable objects) &#x2014;
The list of objects to broadcast. This list will be modified inplace.`,name:"object_list"},{anchor:"accelerate.utils.broadcast_object_list.from_process",description:`<strong>from_process</strong> (<code>int</code>, <em>optional</em>, defaults to 0) &#x2014;
The process from which to send the data.`,name:"from_process"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L560",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The same list containing the objects from process 0.</p>
`}}),Fa=new x({props:{name:"accelerate.utils.concatenate",anchor:"accelerate.utils.concatenate",parameters:[{name:"data",val:""},{name:"dim",val:" = 0"}],parametersDescription:[{anchor:"accelerate.utils.concatenate.data",description:`<strong>data</strong> (nested list/tuple/dictionary of lists of tensors <code>torch.Tensor</code>) &#x2014;
The data to concatenate.`,name:"data"},{anchor:"accelerate.utils.concatenate.dim",description:`<strong>dim</strong> (<code>int</code>, <em>optional</em>, defaults to 0) &#x2014;
The dimension on which to concatenate.`,name:"dim"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L601",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The same data structure as <code>data</code> with all the tensors concatenated.</p>
`}}),Ea=new x({props:{name:"accelerate.utils.convert_outputs_to_fp32",anchor:"accelerate.utils.convert_outputs_to_fp32",parameters:[{name:"model_forward",val:""}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L815"}}),Ia=new x({props:{name:"accelerate.utils.convert_to_fp32",anchor:"accelerate.utils.convert_to_fp32",parameters:[{name:"tensor",val:""}],parametersDescription:[{anchor:"accelerate.utils.convert_to_fp32.tensor",description:`<strong>tensor</strong> (nested list/tuple/dictionary of <code>torch.Tensor</code>) &#x2014;
The data to convert from FP16/BF16 to FP32.`,name:"tensor"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L765",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The same data structure as <code>tensor</code> with all tensors that were in FP16/BF16 precision converted to FP32.</p>
`}}),Aa=new x({props:{name:"accelerate.utils.gather",anchor:"accelerate.utils.gather",parameters:[{name:"tensor",val:""}],parametersDescription:[{anchor:"accelerate.utils.gather.tensor",description:`<strong>tensor</strong> (nested list/tuple/dictionary of <code>torch.Tensor</code>) &#x2014;
The data to gather.`,name:"tensor"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L418",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The same data structure as <code>tensor</code> with all tensors sent to the proper device.</p>
`}}),Sa=new x({props:{name:"accelerate.utils.gather_object",anchor:"accelerate.utils.gather_object",parameters:[{name:"object",val:": typing.Any"}],parametersDescription:[{anchor:"accelerate.utils.gather_object.object",description:`<strong>object</strong> (nested list/tuple/dictionary of picklable object) &#x2014;
The data to gather.`,name:"object"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L445",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The same data structure as <code>object</code> with all the objects sent to every device.</p>
`}}),Oa=new x({props:{name:"accelerate.utils.get_grad_scaler",anchor:"accelerate.utils.get_grad_scaler",parameters:[{name:"distributed_type",val:": DistributedType = None"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"accelerate.utils.get_grad_scaler.distributed_type",description:`<strong>distributed_type</strong> (<code>DistributedType</code>, <em>optional</em>, defaults to None) &#x2014;
The type of distributed environment.`,name:"distributed_type"},{anchor:"accelerate.utils.get_grad_scaler.kwargs",description:`<strong>kwargs</strong> &#x2014;
Additional arguments for the utilized <code>GradScaler</code> constructor.`,name:"kwargs"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L2092"}}),Va=new x({props:{name:"accelerate.utils.get_mixed_precision_context_manager",anchor:"accelerate.utils.get_mixed_precision_context_manager",parameters:[{name:"native_amp",val:": bool = False"},{name:"autocast_kwargs",val:": AutocastKwargs = None"}],parametersDescription:[{anchor:"accelerate.utils.get_mixed_precision_context_manager.native_amp",description:`<strong>native_amp</strong> (<code>bool</code>, <em>optional</em>, defaults to False) &#x2014;
Whether mixed precision is actually enabled.`,name:"native_amp"},{anchor:"accelerate.utils.get_mixed_precision_context_manager.cache_enabled",description:`<strong>cache_enabled</strong> (<code>bool</code>, <em>optional</em>, defaults to True) &#x2014;
Whether the weight cache inside autocast should be enabled.`,name:"cache_enabled"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L2049"}}),qa=new x({props:{name:"accelerate.utils.listify",anchor:"accelerate.utils.listify",parameters:[{name:"data",val:""}],parametersDescription:[{anchor:"accelerate.utils.listify.data",description:"<strong>data</strong> (nested list/tuple/dictionary of <code>torch.Tensor</code>) &#x2014; The data from which to convert to regular numbers.",name:"data"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L278",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The same data structure as <code>data</code> with lists of numbers instead of <code>torch.Tensor</code>.</p>
`}}),Ra=new x({props:{name:"accelerate.utils.pad_across_processes",anchor:"accelerate.utils.pad_across_processes",parameters:[{name:"tensor",val:""},{name:"dim",val:" = 0"},{name:"pad_index",val:" = 0"},{name:"pad_first",val:" = False"}],parametersDescription:[{anchor:"accelerate.utils.pad_across_processes.tensor",description:`<strong>tensor</strong> (nested list/tuple/dictionary of <code>torch.Tensor</code>) &#x2014;
The data to gather.`,name:"tensor"},{anchor:"accelerate.utils.pad_across_processes.dim",description:`<strong>dim</strong> (<code>int</code>, <em>optional</em>, defaults to 0) &#x2014;
The dimension on which to pad.`,name:"dim"},{anchor:"accelerate.utils.pad_across_processes.pad_index",description:`<strong>pad_index</strong> (<code>int</code>, <em>optional</em>, defaults to 0) &#x2014;
The value with which to pad.`,name:"pad_index"},{anchor:"accelerate.utils.pad_across_processes.pad_first",description:`<strong>pad_first</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to pad at the beginning or the end.`,name:"pad_first"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L627"}}),Ha=new x({props:{name:"accelerate.utils.recursively_apply",anchor:"accelerate.utils.recursively_apply",parameters:[{name:"func",val:""},{name:"data",val:""},{name:"*args",val:""},{name:"test_type",val:" = <function is_torch_tensor at 0x7f70f74623b0>"},{name:"error_on_other_type",val:" = False"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"accelerate.utils.recursively_apply.func",description:`<strong>func</strong> (<code>callable</code>) &#x2014;
The function to recursively apply.`,name:"func"},{anchor:"accelerate.utils.recursively_apply.data",description:`<strong>data</strong> (nested list/tuple/dictionary of <code>main_type</code>) &#x2014;
The data on which to apply <code>func</code>`,name:"data"},{anchor:"accelerate.utils.recursively_apply.*args",description:`<strong>*args</strong> &#x2014;
Positional arguments that will be passed to <code>func</code> when applied on the unpacked data.`,name:"*args"},{anchor:"accelerate.utils.recursively_apply.main_type",description:`<strong>main_type</strong> (<code>type</code>, <em>optional</em>, defaults to <code>torch.Tensor</code>) &#x2014;
The base type of the objects to which apply <code>func</code>.`,name:"main_type"},{anchor:"accelerate.utils.recursively_apply.error_on_other_type",description:`<strong>error_on_other_type</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to return an error or not if after unpacking <code>data</code>, we get on an object that is not of type
<code>main_type</code>. If <code>False</code>, the function will leave objects of types different than <code>main_type</code> unchanged.`,name:"error_on_other_type"},{anchor:"accelerate.utils.recursively_apply.*kwargs",description:`*<strong>*kwargs</strong> (additional keyword arguments, <em>optional</em>) &#x2014;
Keyword arguments that will be passed to <code>func</code> when applied on the unpacked data.`,name:"*kwargs"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L85",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The same data structure as <code>data</code> with <code>func</code> applied to every object of type <code>main_type</code>.</p>
`}}),Wa=new x({props:{name:"accelerate.utils.reduce",anchor:"accelerate.utils.reduce",parameters:[{name:"tensor",val:""},{name:"reduction",val:" = 'mean'"},{name:"scale",val:" = 1.0"}],parametersDescription:[{anchor:"accelerate.utils.reduce.tensor",description:`<strong>tensor</strong> (nested list/tuple/dictionary of <code>torch.Tensor</code>) &#x2014;
The data to reduce.`,name:"tensor"},{anchor:"accelerate.utils.reduce.reduction",description:`<strong>reduction</strong> (<code>str</code>, <em>optional</em>, defaults to <code>&quot;mean&quot;</code>) &#x2014;
A reduction method. Can be of &#x201C;mean&#x201D;, &#x201C;sum&#x201D;, or &#x201C;none&#x201D;`,name:"reduction"},{anchor:"accelerate.utils.reduce.scale",description:`<strong>scale</strong> (<code>float</code>, <em>optional</em>) &#x2014;
A default scaling value to be applied after the reduce, only valid on XLA.`,name:"scale"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L723",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The same data structure as <code>data</code> with all the tensors reduced.</p>
`}}),Ga=new x({props:{name:"accelerate.utils.send_to_device",anchor:"accelerate.utils.send_to_device",parameters:[{name:"tensor",val:""},{name:"device",val:""},{name:"non_blocking",val:" = False"},{name:"skip_keys",val:" = None"}],parametersDescription:[{anchor:"accelerate.utils.send_to_device.tensor",description:`<strong>tensor</strong> (nested list/tuple/dictionary of <code>torch.Tensor</code>) &#x2014;
The data to send to a given device.`,name:"tensor"},{anchor:"accelerate.utils.send_to_device.device",description:`<strong>device</strong> (<code>torch.device</code>) &#x2014;
The device to send the data to.`,name:"device"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L136",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The same data structure as <code>tensor</code> with all tensors sent to the proper device.</p>
`}}),Ja=new x({props:{name:"accelerate.utils.slice_tensors",anchor:"accelerate.utils.slice_tensors",parameters:[{name:"data",val:""},{name:"tensor_slice",val:""},{name:"process_index",val:" = None"},{name:"num_processes",val:" = None"}],parametersDescription:[{anchor:"accelerate.utils.slice_tensors.data",description:`<strong>data</strong> (nested list/tuple/dictionary of <code>torch.Tensor</code>) &#x2014;
The data to slice.`,name:"data"},{anchor:"accelerate.utils.slice_tensors.tensor_slice",description:`<strong>tensor_slice</strong> (<code>slice</code>) &#x2014;
The slice to take.`,name:"tensor_slice"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L581",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The same data structure as <code>data</code> with all the tensors slices.</p>
`}}),Ba=new M({props:{title:"Environment Checks",local:"accelerate.utils.is_bf16_available",headingTag:"h2"}}),Za=new x({props:{name:"accelerate.utils.is_bf16_available",anchor:"accelerate.utils.is_bf16_available",parameters:[{name:"ignore_tpu",val:" = False"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/imports.py#L174"}}),Ya=new x({props:{name:"accelerate.utils.is_ipex_available",anchor:"accelerate.utils.is_ipex_available",parameters:[],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/imports.py#L351"}}),Qa=new x({props:{name:"accelerate.utils.is_mps_available",anchor:"accelerate.utils.is_mps_available",parameters:[{name:"min_version",val:" = '1.12'"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/imports.py#L344"}}),Ka=new x({props:{name:"accelerate.utils.is_npu_available",anchor:"accelerate.utils.is_npu_available",parameters:[{name:"check_device",val:" = False"}]}}),eo=new x({props:{name:"accelerate.utils.is_torch_version",anchor:"accelerate.utils.is_torch_version",parameters:[{name:"operation",val:": str"},{name:"version",val:": str"}],parametersDescription:[{anchor:"accelerate.utils.is_torch_version.operation",description:`<strong>operation</strong> (<code>str</code>) &#x2014;
A string representation of an operator, such as <code>&quot;&gt;&quot;</code> or <code>&quot;&lt;=&quot;</code>`,name:"operation"},{anchor:"accelerate.utils.is_torch_version.version",description:`<strong>version</strong> (<code>str</code>) &#x2014;
A string version of PyTorch`,name:"version"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/versions.py#L46"}}),to=new x({props:{name:"accelerate.utils.is_torch_xla_available",anchor:"accelerate.utils.is_torch_xla_available",parameters:[{name:"check_is_tpu",val:" = False"},{name:"check_is_gpu",val:" = False"}]}}),ao=new x({props:{name:"accelerate.utils.is_xpu_available",anchor:"accelerate.utils.is_xpu_available",parameters:[{name:"check_device",val:" = False"}]}}),oo=new M({props:{title:"Environment Manipulation",local:"accelerate.utils.patch_environment",headingTag:"h2"}}),no=new x({props:{name:"accelerate.utils.patch_environment",anchor:"accelerate.utils.patch_environment",parameters:[{name:"**kwargs",val:""}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/environment.py#L325"}}),xt=new rt({props:{anchor:"accelerate.utils.patch_environment.example",$$slots:{default:[ig]},$$scope:{ctx:k}}}),ro=new x({props:{name:"accelerate.utils.clear_environment",anchor:"accelerate.utils.clear_environment",parameters:[],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/environment.py#L290"}}),wt=new rt({props:{anchor:"accelerate.utils.clear_environment.example",$$slots:{default:[cg]},$$scope:{ctx:k}}}),lo=new x({props:{name:"accelerate.commands.config.default.write_basic_config",anchor:"accelerate.commands.config.default.write_basic_config",parameters:[{name:"mixed_precision",val:" = 'no'"},{name:"save_location",val:": str = '/github/home/.cache/huggingface/accelerate/default_config.yaml'"}],parametersDescription:[{anchor:"accelerate.commands.config.default.write_basic_config.mixed_precision",description:`<strong>mixed_precision</strong> (<code>str</code>, <em>optional</em>, defaults to &#x201C;no&#x201D;) &#x2014;
Mixed Precision to use. Should be one of &#x201C;no&#x201D;, &#x201C;fp16&#x201D;, or &#x201C;bf16&#x201D;`,name:"mixed_precision"},{anchor:"accelerate.commands.config.default.write_basic_config.save_location",description:`<strong>save_location</strong> (<code>str</code>, <em>optional</em>, defaults to <code>default_json_config_file</code>) &#x2014;
Optional custom save location. Should be passed to <code>--config_file</code> when using <code>accelerate launch</code>. Default
location is inside the huggingface cache folder (<code>~/.cache/huggingface</code>) but can be overridden by setting
the <code>HF_HOME</code> environmental variable, followed by <code>accelerate/default_config.yaml</code>.`,name:"save_location"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/commands/config/default.py#L36"}}),io=new x({props:{name:"accelerate.utils.set_numa_affinity",anchor:"accelerate.utils.set_numa_affinity",parameters:[{name:"local_process_index",val:": int"},{name:"verbose",val:": typing.Optional[bool] = None"}],parametersDescription:[{anchor:"accelerate.utils.set_numa_affinity.local_process_index",description:`<strong>local_process_index</strong> (int) &#x2014;
The index of the current process on the current server.`,name:"local_process_index"},{anchor:"accelerate.utils.set_numa_affinity.verbose",description:`<strong>verbose</strong> (bool, <em>optional</em>) &#x2014;
Whether to print the new cpu cores assignment for each process. If <code>ACCELERATE_DEBUG_MODE</code> is enabled, will
default to True.`,name:"verbose"}]}}),co=new x({props:{name:"accelerate.utils.environment.override_numa_affinity",anchor:"accelerate.utils.environment.override_numa_affinity",parameters:[{name:"local_process_index",val:": int"},{name:"verbose",val:": typing.Optional[bool] = None"}],parametersDescription:[{anchor:"accelerate.utils.environment.override_numa_affinity.local_process_index",description:`<strong>local_process_index</strong> (int) &#x2014;
The index of the current process on the current server.`,name:"local_process_index"},{anchor:"accelerate.utils.environment.override_numa_affinity.verbose",description:`<strong>verbose</strong> (bool, <em>optional</em>) &#x2014;
Whether to log out the assignment of each CPU. If <code>ACCELERATE_DEBUG_MODE</code> is enabled, will default to True.`,name:"verbose"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/environment.py#L233"}}),po=new x({props:{name:"accelerate.utils.purge_accelerate_environment",anchor:"accelerate.utils.purge_accelerate_environment",parameters:[{name:"func_or_cls",val:""}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/environment.py#L362"}}),mo=new M({props:{title:"Memory",local:"accelerate.find_executable_batch_size",headingTag:"h2"}}),uo=new x({props:{name:"accelerate.find_executable_batch_size",anchor:"accelerate.find_executable_batch_size",parameters:[{name:"function",val:": typing.Optional[<built-in function callable>] = None"},{name:"starting_batch_size",val:": int = 128"},{name:"reduce_batch_size_fn",val:": typing.Optional[<built-in function callable>] = None"}],parametersDescription:[{anchor:"accelerate.find_executable_batch_size.function",description:`<strong>function</strong> (<code>callable</code>, <em>optional</em>) &#x2014;
A function to wrap`,name:"function"},{anchor:"accelerate.find_executable_batch_size.starting_batch_size",description:`<strong>starting_batch_size</strong> (<code>int</code>, <em>optional</em>) &#x2014;
The batch size to try and fit into memory`,name:"starting_batch_size"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/memory.py#L120"}}),Ct=new rt({props:{anchor:"accelerate.find_executable_batch_size.example",$$slots:{default:[dg]},$$scope:{ctx:k}}}),go=new M({props:{title:"Modeling",local:"accelerate.utils.calculate_maximum_sizes",headingTag:"h2"}}),fo=new x({props:{name:"accelerate.utils.calculate_maximum_sizes",anchor:"accelerate.utils.calculate_maximum_sizes",parameters:[{name:"model",val:": Module"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1052"}}),_o=new x({props:{name:"accelerate.utils.compute_module_sizes",anchor:"accelerate.utils.compute_module_sizes",parameters:[{name:"model",val:": Module"},{name:"dtype",val:": typing.Union[torch.device, str, NoneType] = None"},{name:"special_dtypes",val:": typing.Optional[dict[str, typing.Union[str, torch.device]]] = None"},{name:"buffers_only",val:": bool = False"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L651"}}),bo=new x({props:{name:"accelerate.utils.extract_model_from_parallel",anchor:"accelerate.utils.extract_model_from_parallel",parameters:[{name:"model",val:""},{name:"keep_fp32_wrapper",val:": bool = True"},{name:"keep_torch_compile",val:": bool = True"},{name:"recursive",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.utils.extract_model_from_parallel.model",description:`<strong>model</strong> (<code>torch.nn.Module</code>) &#x2014;
The model to extract.`,name:"model"},{anchor:"accelerate.utils.extract_model_from_parallel.keep_fp32_wrapper",description:`<strong>keep_fp32_wrapper</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether to remove mixed precision hooks from the model.`,name:"keep_fp32_wrapper"},{anchor:"accelerate.utils.extract_model_from_parallel.keep_torch_compile",description:`<strong>keep_torch_compile</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether to unwrap compiled model.`,name:"keep_torch_compile"},{anchor:"accelerate.utils.extract_model_from_parallel.recursive",description:`<strong>recursive</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to recursively extract all cases of <code>module.module</code> from <code>model</code> as well as unwrap child sublayers
recursively, not just the top-level distributed containers.`,name:"recursive"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L218",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The extracted model.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><code>torch.nn.Module</code></p>
`}}),vo=new x({props:{name:"accelerate.utils.get_balanced_memory",anchor:"accelerate.utils.get_balanced_memory",parameters:[{name:"model",val:": Module"},{name:"max_memory",val:": typing.Optional[dict[typing.Union[int, str], typing.Union[int, str]]] = None"},{name:"no_split_module_classes",val:": typing.Optional[list[str]] = None"},{name:"dtype",val:": typing.Union[str, torch.dtype, NoneType] = None"},{name:"special_dtypes",val:": typing.Optional[dict[str, typing.Union[str, torch.device]]] = None"},{name:"low_zero",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.utils.get_balanced_memory.model",description:`<strong>model</strong> (<code>torch.nn.Module</code>) &#x2014;
The model to analyze.`,name:"model"},{anchor:"accelerate.utils.get_balanced_memory.max_memory",description:`<strong>max_memory</strong> (<code>Dict</code>, <em>optional</em>) &#x2014;
A dictionary device identifier to maximum memory. Will default to the maximum memory available if unset.
Example: <code>max_memory={0: &quot;1GB&quot;}</code>.`,name:"max_memory"},{anchor:"accelerate.utils.get_balanced_memory.no_split_module_classes",description:`<strong>no_split_module_classes</strong> (<code>List[str]</code>, <em>optional</em>) &#x2014;
A list of layer class names that should never be split across device (for instance any layer that has a
residual connection).`,name:"no_split_module_classes"},{anchor:"accelerate.utils.get_balanced_memory.dtype",description:`<strong>dtype</strong> (<code>str</code> or <code>torch.dtype</code>, <em>optional</em>) &#x2014;
If provided, the weights will be converted to that type when loaded.`,name:"dtype"},{anchor:"accelerate.utils.get_balanced_memory.special_dtypes",description:`<strong>special_dtypes</strong> (<code>Dict[str, Union[str, torch.device]]</code>, <em>optional</em>) &#x2014;
If provided, special dtypes to consider for some specific weights (will override dtype used as default for
all weights).`,name:"special_dtypes"},{anchor:"accelerate.utils.get_balanced_memory.low_zero",description:`<strong>low_zero</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Minimizes the number of weights on GPU 0, which is convenient when it&#x2019;s used for other operations (like the
Transformers generate function).`,name:"low_zero"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L918"}}),Tt=new an({props:{$$slots:{default:[pg]},$$scope:{ctx:k}}}),yo=new x({props:{name:"accelerate.utils.get_max_layer_size",anchor:"accelerate.utils.get_max_layer_size",parameters:[{name:"modules",val:": list"},{name:"module_sizes",val:": dict"},{name:"no_split_module_classes",val:": list"}],parametersDescription:[{anchor:"accelerate.utils.get_max_layer_size.modules",description:`<strong>modules</strong> (<code>List[Tuple[str, torch.nn.Module]]</code>) &#x2014;
The list of named modules where we want to determine the maximum layer size.`,name:"modules"},{anchor:"accelerate.utils.get_max_layer_size.module_sizes",description:`<strong>module_sizes</strong> (<code>Dict[str, int]</code>) &#x2014;
A dictionary mapping each layer name to its size (as generated by <code>compute_module_sizes</code>).`,name:"module_sizes"},{anchor:"accelerate.utils.get_max_layer_size.no_split_module_classes",description:`<strong>no_split_module_classes</strong> (<code>List[str]</code>) &#x2014;
A list of class names for layers we don&#x2019;t want to be split.`,name:"no_split_module_classes"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L705",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The maximum size of a layer with the list of layer names realizing that maximum size.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><code>Tuple[int, List[str]]</code></p>
`}}),$o=new x({props:{name:"accelerate.infer_auto_device_map",anchor:"accelerate.infer_auto_device_map",parameters:[{name:"model",val:": Module"},{name:"max_memory",val:": typing.Optional[dict[typing.Union[int, str], typing.Union[int, str]]] = None"},{name:"no_split_module_classes",val:": typing.Optional[list[str]] = None"},{name:"dtype",val:": typing.Union[str, torch.dtype, NoneType] = None"},{name:"special_dtypes",val:": typing.Optional[dict[str, typing.Union[str, torch.dtype]]] = None"},{name:"verbose",val:": bool = False"},{name:"clean_result",val:": bool = True"},{name:"offload_buffers",val:": bool = False"},{name:"fallback_allocation",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.infer_auto_device_map.model",description:`<strong>model</strong> (<code>torch.nn.Module</code>) &#x2014;
The model to analyze.`,name:"model"},{anchor:"accelerate.infer_auto_device_map.max_memory",description:`<strong>max_memory</strong> (<code>Dict</code>, <em>optional</em>) &#x2014;
A dictionary device identifier to maximum memory. Will default to the maximum memory available if unset.
Example: <code>max_memory={0: &quot;1GB&quot;}</code>.`,name:"max_memory"},{anchor:"accelerate.infer_auto_device_map.no_split_module_classes",description:`<strong>no_split_module_classes</strong> (<code>List[str]</code>, <em>optional</em>) &#x2014;
A list of layer class names that should never be split across device (for instance any layer that has a
residual connection).`,name:"no_split_module_classes"},{anchor:"accelerate.infer_auto_device_map.dtype",description:`<strong>dtype</strong> (<code>str</code> or <code>torch.dtype</code>, <em>optional</em>) &#x2014;
If provided, the weights will be converted to that type when loaded.`,name:"dtype"},{anchor:"accelerate.infer_auto_device_map.special_dtypes",description:`<strong>special_dtypes</strong> (<code>Dict[str, Union[str, torch.device]]</code>, <em>optional</em>) &#x2014;
If provided, special dtypes to consider for some specific weights (will override dtype used as default for
all weights).`,name:"special_dtypes"},{anchor:"accelerate.infer_auto_device_map.verbose",description:`<strong>verbose</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to provide debugging statements as the function builds the device_map.`,name:"verbose"},{anchor:"accelerate.infer_auto_device_map.clean_result",description:`<strong>clean_result</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Clean the resulting device_map by grouping all submodules that go on the same device together.`,name:"clean_result"},{anchor:"accelerate.infer_auto_device_map.offload_buffers",description:`<strong>offload_buffers</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
In the layers that are offloaded on the CPU or the hard drive, whether or not to offload the buffers as
well as the parameters.`,name:"offload_buffers"},{anchor:"accelerate.infer_auto_device_map.fallback_allocation",description:`<strong>fallback_allocation</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
When regular allocation fails, try to allocate a module that fits in the size limit using BFS.`,name:"fallback_allocation"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1278"}}),kt=new an({props:{$$slots:{default:[mg]},$$scope:{ctx:k}}}),xo=new x({props:{name:"accelerate.load_checkpoint_in_model",anchor:"accelerate.load_checkpoint_in_model",parameters:[{name:"model",val:": Module"},{name:"checkpoint",val:": typing.Union[str, os.PathLike]"},{name:"device_map",val:": typing.Optional[dict[str, typing.Union[int, str, torch.device]]] = None"},{name:"offload_folder",val:": typing.Union[str, os.PathLike, NoneType] = None"},{name:"dtype",val:": typing.Union[str, torch.dtype, NoneType] = None"},{name:"offload_state_dict",val:": bool = False"},{name:"offload_buffers",val:": bool = False"},{name:"keep_in_fp32_modules",val:": typing.Optional[list[str]] = None"},{name:"offload_8bit_bnb",val:": bool = False"},{name:"strict",val:": bool = False"},{name:"full_state_dict",val:": bool = True"},{name:"broadcast_from_rank0",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.load_checkpoint_in_model.model",description:`<strong>model</strong> (<code>torch.nn.Module</code>) &#x2014;
The model in which we want to load a checkpoint.`,name:"model"},{anchor:"accelerate.load_checkpoint_in_model.checkpoint",description:`<strong>checkpoint</strong> (<code>str</code> or <code>os.PathLike</code>) &#x2014;
The folder checkpoint to load. It can be:
<ul>
<li>a path to a file containing a whole model state dict</li>
<li>a path to a <code>.json</code> file containing the index to a sharded checkpoint</li>
<li>a path to a folder containing a unique <code>.index.json</code> file and the shards of a checkpoint.</li>
<li>a path to a folder containing a unique pytorch_model.bin or a model.safetensors file.</li>
</ul>`,name:"checkpoint"},{anchor:"accelerate.load_checkpoint_in_model.device_map",description:`<strong>device_map</strong> (<code>Dict[str, Union[int, str, torch.device]]</code>, <em>optional</em>) &#x2014;
A map that specifies where each submodule should go. It doesn&#x2019;t need to be refined to each parameter/buffer
name, once a given module name is inside, every submodule of it will be sent to the same device.`,name:"device_map"},{anchor:"accelerate.load_checkpoint_in_model.offload_folder",description:`<strong>offload_folder</strong> (<code>str</code> or <code>os.PathLike</code>, <em>optional</em>) &#x2014;
If the <code>device_map</code> contains any value <code>&quot;disk&quot;</code>, the folder where we will offload weights.`,name:"offload_folder"},{anchor:"accelerate.load_checkpoint_in_model.dtype",description:`<strong>dtype</strong> (<code>str</code> or <code>torch.dtype</code>, <em>optional</em>) &#x2014;
If provided, the weights will be converted to that type when loaded.`,name:"dtype"},{anchor:"accelerate.load_checkpoint_in_model.offload_state_dict",description:`<strong>offload_state_dict</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, will temporarily offload the CPU state dict on the hard drive to avoid getting out of CPU RAM if
the weight of the CPU state dict + the biggest shard does not fit.`,name:"offload_state_dict"},{anchor:"accelerate.load_checkpoint_in_model.offload_buffers",description:`<strong>offload_buffers</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to include the buffers in the weights offloaded to disk.`,name:"offload_buffers"},{anchor:"accelerate.load_checkpoint_in_model.keep_in_fp32_modules(List[str],",description:`<strong>keep_in_fp32_modules(<code>List[str]</code>,</strong> <em>optional</em>) &#x2014;
A list of the modules that we keep in <code>torch.float32</code> dtype.`,name:"keep_in_fp32_modules(List[str],"},{anchor:"accelerate.load_checkpoint_in_model.offload_8bit_bnb",description:`<strong>offload_8bit_bnb</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to enable offload of 8-bit modules on cpu/disk.`,name:"offload_8bit_bnb"},{anchor:"accelerate.load_checkpoint_in_model.strict",description:`<strong>strict</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to strictly enforce that the keys in the checkpoint state_dict match the keys of the model&#x2019;s
state_dict.`,name:"strict"},{anchor:"accelerate.load_checkpoint_in_model.full_state_dict",description:`<strong>full_state_dict</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014; if this is set to <code>True</code>, all the tensors in the
loaded state_dict will be gathered. No ShardedTensor and DTensor will be in the loaded state_dict.`,name:"full_state_dict"},{anchor:"accelerate.load_checkpoint_in_model.broadcast_from_rank0",description:`<strong>broadcast_from_rank0</strong> (<code>False</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014; when the option is <code>True</code>, a distributed
<code>ProcessGroup</code> must be initialized. rank0 should receive a full state_dict and will broadcast the tensors
in the state_dict one by one to other ranks. Other ranks will receive the tensors and shard (if applicable)
according to the local shards in the model.`,name:"broadcast_from_rank0"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1788"}}),Pt=new an({props:{warning:!0,$$slots:{default:[ug]},$$scope:{ctx:k}}}),wo=new x({props:{name:"accelerate.utils.load_offloaded_weights",anchor:"accelerate.utils.load_offloaded_weights",parameters:[{name:"model",val:""},{name:"index",val:""},{name:"offload_folder",val:""}],parametersDescription:[{anchor:"accelerate.utils.load_offloaded_weights.model",description:`<strong>model</strong> (<code>torch.nn.Module</code>) &#x2014;
The model to load the weights into.`,name:"model"},{anchor:"accelerate.utils.load_offloaded_weights.index",description:`<strong>index</strong> (<code>dict</code>) &#x2014;
A dictionary containing the parameter name and its metadata for each parameter that was offloaded from the
model.`,name:"index"},{anchor:"accelerate.utils.load_offloaded_weights.offload_folder",description:`<strong>offload_folder</strong> (<code>str</code>) &#x2014;
The folder where the offloaded weights are stored.`,name:"offload_folder"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L877"}}),Co=new x({props:{name:"accelerate.utils.load_state_dict",anchor:"accelerate.utils.load_state_dict",parameters:[{name:"checkpoint_file",val:""},{name:"device_map",val:" = None"}],parametersDescription:[{anchor:"accelerate.utils.load_state_dict.checkpoint_file",description:"<strong>checkpoint_file</strong> (<code>str</code>) &#x2014; The path to the checkpoint to load.",name:"checkpoint_file"},{anchor:"accelerate.utils.load_state_dict.device_map",description:`<strong>device_map</strong> (<code>Dict[str, Union[int, str, torch.device]]</code>, <em>optional</em>) &#x2014;
A map that specifies where each submodule should go. It doesn&#x2019;t need to be refined to each parameter/buffer
name, once a given module name is inside, every submodule of it will be sent to the same device.`,name:"device_map"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1620"}}),To=new x({props:{name:"accelerate.utils.offload_state_dict",anchor:"accelerate.utils.offload_state_dict",parameters:[{name:"save_dir",val:": typing.Union[str, os.PathLike]"},{name:"state_dict",val:": dict"}],parametersDescription:[{anchor:"accelerate.utils.offload_state_dict.save_dir",description:`<strong>save_dir</strong> (<code>str</code> or <code>os.PathLike</code>) &#x2014;
The directory in which to offload the state dict.`,name:"save_dir"},{anchor:"accelerate.utils.offload_state_dict.state_dict",description:`<strong>state_dict</strong> (<code>Dict[str, torch.Tensor]</code>) &#x2014;
The dictionary of tensors to offload.`,name:"state_dict"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/offload.py#L85"}}),ko=new x({props:{name:"accelerate.utils.retie_parameters",anchor:"accelerate.utils.retie_parameters",parameters:[{name:"model",val:""},{name:"tied_params",val:""}],parametersDescription:[{anchor:"accelerate.utils.retie_parameters.model",description:`<strong>model</strong> (<code>torch.nn.Module</code>) &#x2014;
The model in which to retie parameters.`,name:"model"},{anchor:"accelerate.utils.retie_parameters.tied_params",description:`<strong>tied_params</strong> (<code>List[List[str]]</code>) &#x2014;
A mapping parameter name to tied parameter name as obtained by <code>find_tied_parameters</code>.`,name:"tied_params"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L609"}}),Po=new x({props:{name:"accelerate.utils.set_module_tensor_to_device",anchor:"accelerate.utils.set_module_tensor_to_device",parameters:[{name:"module",val:": Module"},{name:"tensor_name",val:": str"},{name:"device",val:": typing.Union[int, str, torch.device]"},{name:"value",val:": typing.Optional[torch.Tensor] = None"},{name:"dtype",val:": typing.Union[str, torch.dtype, NoneType] = None"},{name:"fp16_statistics",val:": typing.Optional[torch.HalfTensor] = None"},{name:"tied_params_map",val:": typing.Optional[dict[int, dict[torch.device, torch.Tensor]]] = None"},{name:"non_blocking",val:": bool = False"},{name:"clear_cache",val:": bool = True"}],parametersDescription:[{anchor:"accelerate.utils.set_module_tensor_to_device.module",description:`<strong>module</strong> (<code>torch.nn.Module</code>) &#x2014;
The module in which the tensor we want to move lives.`,name:"module"},{anchor:"accelerate.utils.set_module_tensor_to_device.tensor_name",description:`<strong>tensor_name</strong> (<code>str</code>) &#x2014;
The full name of the parameter/buffer.`,name:"tensor_name"},{anchor:"accelerate.utils.set_module_tensor_to_device.device",description:`<strong>device</strong> (<code>int</code>, <code>str</code> or <code>torch.device</code>) &#x2014;
The device on which to set the tensor.`,name:"device"},{anchor:"accelerate.utils.set_module_tensor_to_device.value",description:`<strong>value</strong> (<code>torch.Tensor</code>, <em>optional</em>) &#x2014;
The value of the tensor (useful when going from the meta device to any other device).`,name:"value"},{anchor:"accelerate.utils.set_module_tensor_to_device.dtype",description:`<strong>dtype</strong> (<code>torch.dtype</code>, <em>optional</em>) &#x2014;
If passed along the value of the parameter will be cast to this <code>dtype</code>. Otherwise, <code>value</code> will be cast to
the dtype of the existing parameter in the model.`,name:"dtype"},{anchor:"accelerate.utils.set_module_tensor_to_device.fp16_statistics",description:`<strong>fp16_statistics</strong> (<code>torch.HalfTensor</code>, <em>optional</em>) &#x2014;
The list of fp16 statistics to set on the module, used for 8 bit model serialization.`,name:"fp16_statistics"},{anchor:"accelerate.utils.set_module_tensor_to_device.tied_params_map",description:`<strong>tied_params_map</strong> (Dict[int, Dict[torch.device, torch.Tensor]], <em>optional</em>, defaults to <code>None</code>) &#x2014;
A map of current data pointers to dictionaries of devices to already dispatched tied weights. For a given
execution device, this parameter is useful to reuse the first available pointer of a shared weight on the
device for all others, instead of duplicating memory.`,name:"tied_params_map"},{anchor:"accelerate.utils.set_module_tensor_to_device.non_blocking",description:`<strong>non_blocking</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, the device transfer will be asynchronous with respect to the host, if possible.`,name:"non_blocking"},{anchor:"accelerate.utils.set_module_tensor_to_device.clear_cache",description:`<strong>clear_cache</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not to clear the device cache after setting the tensor on the device.`,name:"clear_cache"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L217"}}),Mo=new x({props:{name:"accelerate.utils.get_module_children_bottom_up",anchor:"accelerate.utils.get_module_children_bottom_up",parameters:[{name:"model",val:": Module"},{name:"return_fqns",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.utils.get_module_children_bottom_up.model",description:"<strong>model</strong> (<code>torch.nn.Module</code>) &#x2014; the model to get the children of",name:"model"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L533",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>a list of children modules of <code>model</code> in bottom-up order. The last element is the
<code>model</code> itself.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><code>list[torch.nn.Module]</code></p>
`}}),Lo=new M({props:{title:"Parallel",local:"accelerate.utils.extract_model_from_parallel",headingTag:"h2"}}),Do=new x({props:{name:"accelerate.utils.extract_model_from_parallel",anchor:"accelerate.utils.extract_model_from_parallel",parameters:[{name:"model",val:""},{name:"keep_fp32_wrapper",val:": bool = True"},{name:"keep_torch_compile",val:": bool = True"},{name:"recursive",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.utils.extract_model_from_parallel.model",description:`<strong>model</strong> (<code>torch.nn.Module</code>) &#x2014;
The model to extract.`,name:"model"},{anchor:"accelerate.utils.extract_model_from_parallel.keep_fp32_wrapper",description:`<strong>keep_fp32_wrapper</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether to remove mixed precision hooks from the model.`,name:"keep_fp32_wrapper"},{anchor:"accelerate.utils.extract_model_from_parallel.keep_torch_compile",description:`<strong>keep_torch_compile</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether to unwrap compiled model.`,name:"keep_torch_compile"},{anchor:"accelerate.utils.extract_model_from_parallel.recursive",description:`<strong>recursive</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to recursively extract all cases of <code>module.module</code> from <code>model</code> as well as unwrap child sublayers
recursively, not just the top-level distributed containers.`,name:"recursive"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L218",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The extracted model.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><code>torch.nn.Module</code></p>
`}}),Uo=new x({props:{name:"accelerate.utils.save",anchor:"accelerate.utils.save",parameters:[{name:"obj",val:""},{name:"f",val:""},{name:"save_on_each_node",val:": bool = False"},{name:"safe_serialization",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.utils.save.obj",description:`<strong>obj</strong> &#x2014;
The data to save`,name:"obj"},{anchor:"accelerate.utils.save.f",description:`<strong>f</strong> &#x2014;
The file (or file-like object) to use to save the data`,name:"f"},{anchor:"accelerate.utils.save.save_on_each_node",description:`<strong>save_on_each_node</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to only save on the global main process`,name:"save_on_each_node"},{anchor:"accelerate.utils.save.safe_serialization",description:`<strong>safe_serialization</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to save <code>obj</code> using <code>safetensors</code> or the traditional PyTorch way (that uses <code>pickle</code>).`,name:"safe_serialization"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L351"}}),jo=new x({props:{name:"accelerate.utils.load",anchor:"accelerate.utils.load",parameters:[{name:"f",val:""},{name:"map_location",val:" = None"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"accelerate.utils.load.f",description:`<strong>f</strong> &#x2014;
The file (or file-like object) to use to load the data`,name:"f"},{anchor:"accelerate.utils.load.map_location",description:`<strong>map_location</strong> &#x2014;
a function, <code>torch.device</code>, string or a dict specifying how to remap storage locations`,name:"map_location"},{anchor:"accelerate.utils.load.*kwargs",description:`*<strong>*kwargs</strong> &#x2014;
Additional keyword arguments to pass to <code>torch.load()</code>.`,name:"*kwargs"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L401"}}),Fo=new x({props:{name:"accelerate.utils.wait_for_everyone",anchor:"accelerate.utils.wait_for_everyone",parameters:[],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L303"}}),Mt=new an({props:{warning:!0,$$slots:{default:[gg]},$$scope:{ctx:k}}}),zo=new M({props:{title:"Random",local:"accelerate.utils.set_seed",headingTag:"h2"}}),Io=new x({props:{name:"accelerate.utils.set_seed",anchor:"accelerate.utils.set_seed",parameters:[{name:"seed",val:": int"},{name:"device_specific",val:": bool = False"},{name:"deterministic",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.utils.set_seed.seed",description:`<strong>seed</strong> (<code>int</code>) &#x2014;
The seed to set.`,name:"seed"},{anchor:"accelerate.utils.set_seed.device_specific",description:`<strong>device_specific</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to differ the seed on each device slightly with <code>self.process_index</code>.`,name:"device_specific"},{anchor:"accelerate.utils.set_seed.deterministic",description:`<strong>deterministic</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to use deterministic algorithms where available. Can slow down training.`,name:"deterministic"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/random.py#L39"}}),So=new x({props:{name:"accelerate.utils.synchronize_rng_state",anchor:"accelerate.utils.synchronize_rng_state",parameters:[{name:"rng_type",val:": typing.Optional[accelerate.utils.dataclasses.RNGType] = None"},{name:"generator",val:": typing.Optional[torch._C.Generator] = None"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/random.py#L78"}}),Vo=new x({props:{name:"accelerate.synchronize_rng_states",anchor:"accelerate.synchronize_rng_states",parameters:[{name:"rng_types",val:": list"},{name:"generator",val:": typing.Optional[torch._C.Generator] = None"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/random.py#L154"}}),qo=new M({props:{title:"PyTorch XLA",local:"accelerate.utils.install_xla",headingTag:"h2"}}),Ho=new x({props:{name:"accelerate.utils.install_xla",anchor:"accelerate.utils.install_xla",parameters:[{name:"upgrade",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.utils.install_xla.upgrade",description:`<strong>upgrade</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to upgrade <code>torch</code> and install the latest <code>torch_xla</code> wheels.`,name:"upgrade"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/torch_xla.py#L20"}}),Lt=new rt({props:{anchor:"accelerate.utils.install_xla.example",$$slots:{default:[hg]},$$scope:{ctx:k}}}),Wo=new M({props:{title:"Loading model weights",local:"accelerate.load_checkpoint_in_model",headingTag:"h2"}}),Jo=new x({props:{name:"accelerate.load_checkpoint_in_model",anchor:"accelerate.load_checkpoint_in_model",parameters:[{name:"model",val:": Module"},{name:"checkpoint",val:": typing.Union[str, os.PathLike]"},{name:"device_map",val:": typing.Optional[dict[str, typing.Union[int, str, torch.device]]] = None"},{name:"offload_folder",val:": typing.Union[str, os.PathLike, NoneType] = None"},{name:"dtype",val:": typing.Union[str, torch.dtype, NoneType] = None"},{name:"offload_state_dict",val:": bool = False"},{name:"offload_buffers",val:": bool = False"},{name:"keep_in_fp32_modules",val:": typing.Optional[list[str]] = None"},{name:"offload_8bit_bnb",val:": bool = False"},{name:"strict",val:": bool = False"},{name:"full_state_dict",val:": bool = True"},{name:"broadcast_from_rank0",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.load_checkpoint_in_model.model",description:`<strong>model</strong> (<code>torch.nn.Module</code>) &#x2014;
The model in which we want to load a checkpoint.`,name:"model"},{anchor:"accelerate.load_checkpoint_in_model.checkpoint",description:`<strong>checkpoint</strong> (<code>str</code> or <code>os.PathLike</code>) &#x2014;
The folder checkpoint to load. It can be:
<ul>
<li>a path to a file containing a whole model state dict</li>
<li>a path to a <code>.json</code> file containing the index to a sharded checkpoint</li>
<li>a path to a folder containing a unique <code>.index.json</code> file and the shards of a checkpoint.</li>
<li>a path to a folder containing a unique pytorch_model.bin or a model.safetensors file.</li>
</ul>`,name:"checkpoint"},{anchor:"accelerate.load_checkpoint_in_model.device_map",description:`<strong>device_map</strong> (<code>Dict[str, Union[int, str, torch.device]]</code>, <em>optional</em>) &#x2014;
A map that specifies where each submodule should go. It doesn&#x2019;t need to be refined to each parameter/buffer
name, once a given module name is inside, every submodule of it will be sent to the same device.`,name:"device_map"},{anchor:"accelerate.load_checkpoint_in_model.offload_folder",description:`<strong>offload_folder</strong> (<code>str</code> or <code>os.PathLike</code>, <em>optional</em>) &#x2014;
If the <code>device_map</code> contains any value <code>&quot;disk&quot;</code>, the folder where we will offload weights.`,name:"offload_folder"},{anchor:"accelerate.load_checkpoint_in_model.dtype",description:`<strong>dtype</strong> (<code>str</code> or <code>torch.dtype</code>, <em>optional</em>) &#x2014;
If provided, the weights will be converted to that type when loaded.`,name:"dtype"},{anchor:"accelerate.load_checkpoint_in_model.offload_state_dict",description:`<strong>offload_state_dict</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, will temporarily offload the CPU state dict on the hard drive to avoid getting out of CPU RAM if
the weight of the CPU state dict + the biggest shard does not fit.`,name:"offload_state_dict"},{anchor:"accelerate.load_checkpoint_in_model.offload_buffers",description:`<strong>offload_buffers</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether or not to include the buffers in the weights offloaded to disk.`,name:"offload_buffers"},{anchor:"accelerate.load_checkpoint_in_model.keep_in_fp32_modules(List[str],",description:`<strong>keep_in_fp32_modules(<code>List[str]</code>,</strong> <em>optional</em>) &#x2014;
A list of the modules that we keep in <code>torch.float32</code> dtype.`,name:"keep_in_fp32_modules(List[str],"},{anchor:"accelerate.load_checkpoint_in_model.offload_8bit_bnb",description:`<strong>offload_8bit_bnb</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to enable offload of 8-bit modules on cpu/disk.`,name:"offload_8bit_bnb"},{anchor:"accelerate.load_checkpoint_in_model.strict",description:`<strong>strict</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to strictly enforce that the keys in the checkpoint state_dict match the keys of the model&#x2019;s
state_dict.`,name:"strict"},{anchor:"accelerate.load_checkpoint_in_model.full_state_dict",description:`<strong>full_state_dict</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014; if this is set to <code>True</code>, all the tensors in the
loaded state_dict will be gathered. No ShardedTensor and DTensor will be in the loaded state_dict.`,name:"full_state_dict"},{anchor:"accelerate.load_checkpoint_in_model.broadcast_from_rank0",description:`<strong>broadcast_from_rank0</strong> (<code>False</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014; when the option is <code>True</code>, a distributed
<code>ProcessGroup</code> must be initialized. rank0 should receive a full state_dict and will broadcast the tensors
in the state_dict one by one to other ranks. Other ranks will receive the tensors and shard (if applicable)
according to the local shards in the model.`,name:"broadcast_from_rank0"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1788"}}),Nt=new an({props:{warning:!0,$$slots:{default:[fg]},$$scope:{ctx:k}}}),Bo=new M({props:{title:"Quantization",local:"accelerate.utils.load_and_quantize_model",headingTag:"h2"}}),Zo=new x({props:{name:"accelerate.utils.load_and_quantize_model",anchor:"accelerate.utils.load_and_quantize_model",parameters:[{name:"model",val:": Module"},{name:"bnb_quantization_config",val:": BnbQuantizationConfig"},{name:"weights_location",val:": typing.Union[str, os.PathLike, NoneType] = None"},{name:"device_map",val:": typing.Optional[dict[str, typing.Union[int, str, torch.device]]] = None"},{name:"no_split_module_classes",val:": typing.Optional[list[str]] = None"},{name:"max_memory",val:": typing.Optional[dict[typing.Union[int, str], typing.Union[int, str]]] = None"},{name:"offload_folder",val:": typing.Union[str, os.PathLike, NoneType] = None"},{name:"offload_state_dict",val:": bool = False"}],parametersDescription:[{anchor:"accelerate.utils.load_and_quantize_model.model",description:`<strong>model</strong> (<code>torch.nn.Module</code>) &#x2014;
Input model. The model can be already loaded or on the meta device`,name:"model"},{anchor:"accelerate.utils.load_and_quantize_model.bnb_quantization_config",description:`<strong>bnb_quantization_config</strong> (<code>BnbQuantizationConfig</code>) &#x2014;
The bitsandbytes quantization parameters`,name:"bnb_quantization_config"},{anchor:"accelerate.utils.load_and_quantize_model.weights_location",description:`<strong>weights_location</strong> (<code>str</code> or <code>os.PathLike</code>) &#x2014;
The folder weights_location to load. It can be:
<ul>
<li>a path to a file containing a whole model state dict</li>
<li>a path to a <code>.json</code> file containing the index to a sharded checkpoint</li>
<li>a path to a folder containing a unique <code>.index.json</code> file and the shards of a checkpoint.</li>
<li>a path to a folder containing a unique pytorch_model.bin file.</li>
</ul>`,name:"weights_location"},{anchor:"accelerate.utils.load_and_quantize_model.device_map",description:`<strong>device_map</strong> (<code>Dict[str, Union[int, str, torch.device]]</code>, <em>optional</em>) &#x2014;
A map that specifies where each submodule should go. It doesn&#x2019;t need to be refined to each parameter/buffer
name, once a given module name is inside, every submodule of it will be sent to the same device.`,name:"device_map"},{anchor:"accelerate.utils.load_and_quantize_model.no_split_module_classes",description:`<strong>no_split_module_classes</strong> (<code>List[str]</code>, <em>optional</em>) &#x2014;
A list of layer class names that should never be split across device (for instance any layer that has a
residual connection).`,name:"no_split_module_classes"},{anchor:"accelerate.utils.load_and_quantize_model.max_memory",description:`<strong>max_memory</strong> (<code>Dict</code>, <em>optional</em>) &#x2014;
A dictionary device identifier to maximum memory. Will default to the maximum memory available if unset.`,name:"max_memory"},{anchor:"accelerate.utils.load_and_quantize_model.offload_folder",description:`<strong>offload_folder</strong> (<code>str</code> or <code>os.PathLike</code>, <em>optional</em>) &#x2014;
If the <code>device_map</code> contains any value <code>&quot;disk&quot;</code>, the folder where we will offload weights.`,name:"offload_folder"},{anchor:"accelerate.utils.load_and_quantize_model.offload_state_dict",description:`<strong>offload_state_dict</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
If <code>True</code>, will temporarily offload the CPU state dict on the hard drive to avoid getting out of CPU RAM if
the weight of the CPU state dict + the biggest shard does not fit.`,name:"offload_state_dict"}],source:"https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/bnb.py#L44",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The quantized model</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><code>torch.nn.Module</code></p>
`}}),Yo=new eg({props:{source:"https://github.com/huggingface/accelerate/blob/main/docs/source/package_reference/utilities.md"}}),{c(){d=s("meta"),w=o(),b=s("p"),v=o(),m(C.$$.fragment),p=o(),m(T.$$.fragment),dl=o(),zt=s("p"),zt.textContent=Mp,pl=o(),m(Et.$$.fragment),ml=o(),It=s("p"),It.textContent=Lp,ul=o(),At=s("p"),At.innerHTML=Np,gl=o(),St=s("p"),St.innerHTML=Dp,hl=o(),Ot=s("p"),Ot.innerHTML=Up,fl=o(),Vt=s("p"),Vt.innerHTML=jp,_l=o(),m(qt.$$.fragment),bl=o(),Rt=s("p"),Rt.textContent=Fp,vl=o(),m(Ht.$$.fragment),yl=o(),Wt=s("p"),Wt.textContent=zp,$l=o(),U=s("div"),m(Gt.$$.fragment),cc=o(),on=s("p"),on.textContent=Ep,dc=o(),nn=s("p"),nn.textContent=Ip,pc=o(),rn=s("ul"),rn.innerHTML=Ap,xl=o(),j=s("div"),m(Jt.$$.fragment),mc=o(),ln=s("p"),ln.textContent=Sp,uc=o(),sn=s("p"),sn.textContent=Op,gc=o(),cn=s("ul"),cn.innerHTML=Vp,wl=o(),F=s("div"),m(Bt.$$.fragment),hc=o(),dn=s("p"),dn.innerHTML=qp,fc=o(),pn=s("p"),pn.textContent=Rp,_c=o(),mn=s("ul"),mn.innerHTML=Hp,Cl=o(),z=s("div"),m(Xt.$$.fragment),bc=o(),un=s("p"),un.textContent=Wp,vc=o(),gn=s("p"),gn.textContent=Gp,yc=o(),hn=s("ul"),hn.innerHTML=Jp,Tl=o(),E=s("div"),m(Zt.$$.fragment),$c=o(),fn=s("p"),fn.textContent=Bp,xc=o(),_n=s("p"),_n.textContent=Xp,wc=o(),bn=s("ul"),bn.innerHTML=Zp,kl=o(),he=s("div"),m(Yt.$$.fragment),Cc=o(),vn=s("p"),vn.textContent=Yp,Pl=o(),I=s("div"),m(Qt.$$.fragment),Tc=o(),yn=s("p"),yn.textContent=Qp,kc=o(),$n=s("p"),$n.textContent=Kp,Pc=o(),xn=s("ul"),xn.innerHTML=em,Ml=o(),m(Kt.$$.fragment),Ll=o(),ea=s("p"),ea.textContent=tm,Nl=o(),J=s("div"),m(ta.$$.fragment),Mc=o(),wn=s("p"),wn.innerHTML=am,Lc=o(),m(st.$$.fragment),Dl=o(),A=s("div"),m(aa.$$.fragment),Nc=o(),Cn=s("p"),Cn.innerHTML=om,Dc=o(),m(it.$$.fragment),Uc=o(),m(ct.$$.fragment),Ul=o(),fe=s("div"),m(oa.$$.fragment),jc=o(),Tn=s("p"),Tn.innerHTML=nm,jl=o(),S=s("div"),m(na.$$.fragment),Fc=o(),kn=s("p"),kn.innerHTML=rm,zc=o(),m(dt.$$.fragment),Ec=o(),m(pt.$$.fragment),Fl=o(),O=s("div"),m(ra.$$.fragment),Ic=o(),Pn=s("p"),Pn.innerHTML=lm,Ac=o(),Mn=s("p"),Mn.innerHTML=sm,Sc=o(),m(mt.$$.fragment),zl=o(),B=s("div"),m(la.$$.fragment),Oc=o(),Ln=s("p"),Ln.innerHTML=im,Vc=o(),ut=s("div"),m(sa.$$.fragment),qc=o(),Nn=s("p"),Nn.textContent=cm,El=o(),m(ia.$$.fragment),Il=o(),ca=s("p"),ca.innerHTML=dm,Al=o(),V=s("div"),m(da.$$.fragment),Rc=o(),Dn=s("p"),Dn.textContent=pm,Hc=o(),gt=s("div"),m(pa.$$.fragment),Wc=o(),Un=s("p"),Un.textContent=mm,Gc=o(),ht=s("div"),m(ma.$$.fragment),Jc=o(),jn=s("p"),jn.textContent=um,Sl=o(),L=s("div"),m(ua.$$.fragment),Bc=o(),Fn=s("p"),Fn.textContent=gm,Xc=o(),ft=s("div"),m(ga.$$.fragment),Zc=o(),zn=s("p"),zn.innerHTML=hm,Yc=o(),_t=s("div"),m(ha.$$.fragment),Qc=o(),En=s("p"),En.textContent=fm,Kc=o(),bt=s("div"),m(fa.$$.fragment),ed=o(),In=s("p"),In.innerHTML=_m,td=o(),vt=s("div"),m(_a.$$.fragment),ad=o(),An=s("p"),An.textContent=bm,Ol=o(),X=s("div"),m(ba.$$.fragment),od=o(),Sn=s("p"),Sn.innerHTML=vm,nd=o(),m(yt.$$.fragment),Vl=o(),_e=s("div"),m(va.$$.fragment),rd=o(),On=s("p"),On.textContent=ym,ql=o(),be=s("div"),m(ya.$$.fragment),ld=o(),Vn=s("p"),Vn.textContent=$m,Rl=o(),m($a.$$.fragment),Hl=o(),xa=s("p"),xa.textContent=xm,Wl=o(),ve=s("div"),m(wa.$$.fragment),sd=o(),qn=s("p"),qn.textContent=wm,Gl=o(),ye=s("div"),m(Ca.$$.fragment),id=o(),Rn=s("p"),Rn.innerHTML=Cm,Jl=o(),Z=s("div"),m(Ta.$$.fragment),cd=o(),Hn=s("p"),Hn.textContent=Tm,dd=o(),$t=s("div"),m(ka.$$.fragment),pd=o(),Wn=s("p"),Wn.innerHTML=km,Bl=o(),m(Pa.$$.fragment),Xl=o(),Ma=s("p"),Ma.textContent=Pm,Zl=o(),La=s("ul"),La.innerHTML=Mm,Yl=o(),m(Na.$$.fragment),Ql=o(),Da=s("p"),Da.innerHTML=Lm,Kl=o(),$e=s("div"),m(Ua.$$.fragment),md=o(),Gn=s("p"),Gn.textContent=Nm,es=o(),xe=s("div"),m(ja.$$.fragment),ud=o(),Jn=s("p"),Jn.textContent=Dm,ts=o(),we=s("div"),m(Fa.$$.fragment),gd=o(),Bn=s("p"),Bn.textContent=Um,as=o(),za=s("div"),m(Ea.$$.fragment),os=o(),Ce=s("div"),m(Ia.$$.fragment),hd=o(),Xn=s("p"),Xn.textContent=jm,ns=o(),Te=s("div"),m(Aa.$$.fragment),fd=o(),Zn=s("p"),Zn.textContent=Fm,rs=o(),ke=s("div"),m(Sa.$$.fragment),_d=o(),Yn=s("p"),Yn.textContent=zm,ls=o(),Pe=s("div"),m(Oa.$$.fragment),bd=o(),Qn=s("p"),Qn.innerHTML=Em,ss=o(),Me=s("div"),m(Va.$$.fragment),vd=o(),Kn=s("p"),Kn.textContent=Im,is=o(),Le=s("div"),m(qa.$$.fragment),yd=o(),er=s("p"),er.textContent=Am,cs=o(),Ne=s("div"),m(Ra.$$.fragment),$d=o(),tr=s("p"),tr.textContent=Sm,ds=o(),De=s("div"),m(Ha.$$.fragment),xd=o(),ar=s("p"),ar.textContent=Om,ps=o(),Ue=s("div"),m(Wa.$$.fragment),wd=o(),or=s("p"),or.textContent=Vm,ms=o(),je=s("div"),m(Ga.$$.fragment),Cd=o(),nr=s("p"),nr.textContent=qm,us=o(),Fe=s("div"),m(Ja.$$.fragment),Td=o(),rr=s("p"),rr.textContent=Rm,gs=o(),m(Ba.$$.fragment),hs=o(),Xa=s("p"),Xa.textContent=Hm,fs=o(),ze=s("div"),m(Za.$$.fragment),kd=o(),lr=s("p"),lr.textContent=Wm,_s=o(),Ee=s("div"),m(Ya.$$.fragment),Pd=o(),sr=s("p"),sr.textContent=Gm,bs=o(),Ie=s("div"),m(Qa.$$.fragment),Md=o(),ir=s("p"),ir.textContent=Jm,vs=o(),Ae=s("div"),m(Ka.$$.fragment),Ld=o(),cr=s("p"),cr.innerHTML=Bm,ys=o(),Se=s("div"),m(eo.$$.fragment),Nd=o(),dr=s("p"),dr.textContent=Xm,$s=o(),Oe=s("div"),m(to.$$.fragment),Dd=o(),pr=s("p"),pr.innerHTML=Zm,xs=o(),Ve=s("div"),m(ao.$$.fragment),Ud=o(),mr=s("p"),mr.innerHTML=Ym,ws=o(),m(oo.$$.fragment),Cs=o(),q=s("div"),m(no.$$.fragment),jd=o(),ur=s("p"),ur.innerHTML=Qm,Fd=o(),gr=s("p"),gr.innerHTML=Km,zd=o(),m(xt.$$.fragment),Ts=o(),R=s("div"),m(ro.$$.fragment),Ed=o(),hr=s("p"),hr.textContent=eu,Id=o(),fr=s("p"),fr.textContent=tu,Ad=o(),m(wt.$$.fragment),ks=o(),qe=s("div"),m(lo.$$.fragment),Sd=o(),_r=s("p"),_r.textContent=au,Ps=o(),so=s("p"),so.innerHTML=ou,Ms=o(),Y=s("div"),m(io.$$.fragment),Od=o(),br=s("p"),br.textContent=nu,Vd=o(),vr=s("p"),vr.innerHTML=ru,Ls=o(),Re=s("div"),m(co.$$.fragment),qd=o(),yr=s("p"),yr.innerHTML=lu,Ns=o(),P=s("div"),m(po.$$.fragment),Rd=o(),$r=s("p"),$r.textContent=su,Hd=o(),xr=s("p"),xr.textContent=iu,Wd=o(),wr=s("p"),wr.textContent=cu,Gd=o(),Cr=s("p"),Cr.textContent=du,Jd=o(),Tr=s("p"),Tr.textContent=pu,Bd=o(),kr=s("p"),kr.textContent=mu,Ds=o(),m(mo.$$.fragment),Us=o(),H=s("div"),m(uo.$$.fragment),Xd=o(),Pr=s("p"),Pr.innerHTML=uu,Zd=o(),Mr=s("p"),Mr.innerHTML=gu,Yd=o(),m(Ct.$$.fragment),js=o(),m(go.$$.fragment),Fs=o(),ho=s("p"),ho.textContent=hu,zs=o(),He=s("div"),m(fo.$$.fragment),Qd=o(),Lr=s("p"),Lr.textContent=fu,Es=o(),We=s("div"),m(_o.$$.fragment),Kd=o(),Nr=s("p"),Nr.textContent=_u,Is=o(),Ge=s("div"),m(bo.$$.fragment),ep=o(),Dr=s("p"),Dr.textContent=bu,As=o(),Q=s("div"),m(vo.$$.fragment),tp=o(),Ur=s("p"),Ur.innerHTML=vu,ap=o(),m(Tt.$$.fragment),Ss=o(),K=s("div"),m(yo.$$.fragment),op=o(),jr=s("p"),jr.textContent=yu,np=o(),Fr=s("ul"),Fr.innerHTML=$u,Os=o(),W=s("div"),m($o.$$.fragment),rp=o(),zr=s("p"),zr.textContent=xu,lp=o(),Er=s("ul"),Er.innerHTML=wu,sp=o(),m(kt.$$.fragment),Vs=o(),ee=s("div"),m(xo.$$.fragment),ip=o(),Ir=s("p"),Ir.textContent=Cu,cp=o(),m(Pt.$$.fragment),qs=o(),Je=s("div"),m(wo.$$.fragment),dp=o(),Ar=s("p"),Ar.textContent=Tu,Rs=o(),Be=s("div"),m(Co.$$.fragment),pp=o(),Sr=s("p"),Sr.textContent=ku,Hs=o(),Xe=s("div"),m(To.$$.fragment),mp=o(),Or=s("p"),Or.textContent=Pu,Ws=o(),Ze=s("div"),m(ko.$$.fragment),up=o(),Vr=s("p"),Vr.textContent=Mu,Gs=o(),Ye=s("div"),m(Po.$$.fragment),gp=o(),qr=s("p"),qr.innerHTML=Lu,Js=o(),Qe=s("div"),m(Mo.$$.fragment),hp=o(),Rr=s("p"),Rr.textContent=Nu,Bs=o(),m(Lo.$$.fragment),Xs=o(),No=s("p"),No.textContent=Du,Zs=o(),Ke=s("div"),m(Do.$$.fragment),fp=o(),Hr=s("p"),Hr.textContent=Uu,Ys=o(),et=s("div"),m(Uo.$$.fragment),_p=o(),Wr=s("p"),Wr.innerHTML=ju,Qs=o(),te=s("div"),m(jo.$$.fragment),bp=o(),Gr=s("p"),Gr.innerHTML=Fu,vp=o(),Jr=s("p"),Jr.textContent=zu,Ks=o(),ae=s("div"),m(Fo.$$.fragment),yp=o(),Br=s("p"),Br.textContent=Eu,$p=o(),m(Mt.$$.fragment),ei=o(),m(zo.$$.fragment),ti=o(),Eo=s("p"),Eo.textContent=Iu,ai=o(),tt=s("div"),m(Io.$$.fragment),xp=o(),Xr=s("p"),Xr.innerHTML=Au,oi=o(),Ao=s("div"),m(So.$$.fragment),ni=o(),Oo=s("div"),m(Vo.$$.fragment),ri=o(),m(qo.$$.fragment),li=o(),Ro=s("p"),Ro.textContent=Su,si=o(),oe=s("div"),m(Ho.$$.fragment),wp=o(),Zr=s("p"),Zr.innerHTML=Ou,Cp=o(),m(Lt.$$.fragment),ii=o(),m(Wo.$$.fragment),ci=o(),Go=s("p"),Go.textContent=Vu,di=o(),ne=s("div"),m(Jo.$$.fragment),Tp=o(),Yr=s("p"),Yr.textContent=qu,kp=o(),m(Nt.$$.fragment),pi=o(),m(Bo.$$.fragment),mi=o(),Xo=s("p"),Xo.textContent=Ru,ui=o(),at=s("div"),m(Zo.$$.fragment),Pp=o(),Qr=s("p"),Qr.innerHTML=Hu,gi=o(),m(Yo.$$.fragment),hi=o(),cl=s("p"),this.h()},l(e){const a=Qu("svelte-u9bgzb",document.head);d=i(a,"META",{name:!0,content:!0}),a.forEach(t),w=n(e),b=i(e,"P",{}),y(b).forEach(t),v=n(e),u(C.$$.fragment,e),p=n(e),u(T.$$.fragment,e),dl=n(e),zt=i(e,"P",{"data-svelte-h":!0}),c(zt)!=="svelte-1opyj5n"&&(zt.textContent=Mp),pl=n(e),u(Et.$$.fragment,e),ml=n(e),It=i(e,"P",{"data-svelte-h":!0}),c(It)!=="svelte-rtwln7"&&(It.textContent=Lp),ul=n(e),At=i(e,"P",{"data-svelte-h":!0}),c(At)!=="svelte-sw43pa"&&(At.innerHTML=Np),gl=n(e),St=i(e,"P",{"data-svelte-h":!0}),c(St)!=="svelte-197v0qk"&&(St.innerHTML=Dp),hl=n(e),Ot=i(e,"P",{"data-svelte-h":!0}),c(Ot)!=="svelte-92j1zi"&&(Ot.innerHTML=Up),fl=n(e),Vt=i(e,"P",{"data-svelte-h":!0}),c(Vt)!=="svelte-1c1hnpu"&&(Vt.innerHTML=jp),_l=n(e),u(qt.$$.fragment,e),bl=n(e),Rt=i(e,"P",{"data-svelte-h":!0}),c(Rt)!=="svelte-l8y4lq"&&(Rt.textContent=Fp),vl=n(e),u(Ht.$$.fragment,e),yl=n(e),Wt=i(e,"P",{"data-svelte-h":!0}),c(Wt)!=="svelte-cwhjwk"&&(Wt.textContent=zp),$l=n(e),U=i(e,"DIV",{class:!0});var re=y(U);u(Gt.$$.fragment,re),cc=n(re),on=i(re,"P",{"data-svelte-h":!0}),c(on)!=="svelte-wf2a9a"&&(on.textContent=Ep),dc=n(re),nn=i(re,"P",{"data-svelte-h":!0}),c(nn)!=="svelte-1hn5iks"&&(nn.textContent=Ip),pc=n(re),rn=i(re,"UL",{"data-svelte-h":!0}),c(rn)!=="svelte-1opfktt"&&(rn.innerHTML=Ap),re.forEach(t),xl=n(e),j=i(e,"DIV",{class:!0});var le=y(j);u(Jt.$$.fragment,le),mc=n(le),ln=i(le,"P",{"data-svelte-h":!0}),c(ln)!=="svelte-1phk8bn"&&(ln.textContent=Sp),uc=n(le),sn=i(le,"P",{"data-svelte-h":!0}),c(sn)!=="svelte-1hn5iks"&&(sn.textContent=Op),gc=n(le),cn=i(le,"UL",{"data-svelte-h":!0}),c(cn)!=="svelte-1vyppch"&&(cn.innerHTML=Vp),le.forEach(t),wl=n(e),F=i(e,"DIV",{class:!0});var se=y(F);u(Bt.$$.fragment,se),hc=n(se),dn=i(se,"P",{"data-svelte-h":!0}),c(dn)!=="svelte-1l113rz"&&(dn.innerHTML=qp),fc=n(se),pn=i(se,"P",{"data-svelte-h":!0}),c(pn)!=="svelte-1hn5iks"&&(pn.textContent=Rp),_c=n(se),mn=i(se,"UL",{"data-svelte-h":!0}),c(mn)!=="svelte-7mhnkp"&&(mn.innerHTML=Hp),se.forEach(t),Cl=n(e),z=i(e,"DIV",{class:!0});var ie=y(z);u(Xt.$$.fragment,ie),bc=n(ie),un=i(ie,"P",{"data-svelte-h":!0}),c(un)!=="svelte-1r8llng"&&(un.textContent=Wp),vc=n(ie),gn=i(ie,"P",{"data-svelte-h":!0}),c(gn)!=="svelte-1hn5iks"&&(gn.textContent=Gp),yc=n(ie),hn=i(ie,"UL",{"data-svelte-h":!0}),c(hn)!=="svelte-8tnxrp"&&(hn.innerHTML=Jp),ie.forEach(t),Tl=n(e),E=i(e,"DIV",{class:!0});var ce=y(E);u(Zt.$$.fragment,ce),$c=n(ce),fn=i(ce,"P",{"data-svelte-h":!0}),c(fn)!=="svelte-1i67rqt"&&(fn.textContent=Bp),xc=n(ce),_n=i(ce,"P",{"data-svelte-h":!0}),c(_n)!=="svelte-1hn5iks"&&(_n.textContent=Xp),wc=n(ce),bn=i(ce,"UL",{"data-svelte-h":!0}),c(bn)!=="svelte-1qjoupb"&&(bn.innerHTML=Zp),ce.forEach(t),kl=n(e),he=i(e,"DIV",{class:!0});var Qo=y(he);u(Yt.$$.fragment,Qo),Cc=n(Qo),vn=i(Qo,"P",{"data-svelte-h":!0}),c(vn)!=="svelte-ofujqi"&&(vn.textContent=Yp),Qo.forEach(t),Pl=n(e),I=i(e,"DIV",{class:!0});var de=y(I);u(Qt.$$.fragment,de),Tc=n(de),yn=i(de,"P",{"data-svelte-h":!0}),c(yn)!=="svelte-1phk8bn"&&(yn.textContent=Qp),kc=n(de),$n=i(de,"P",{"data-svelte-h":!0}),c($n)!=="svelte-1hn5iks"&&($n.textContent=Kp),Pc=n(de),xn=i(de,"UL",{"data-svelte-h":!0}),c(xn)!=="svelte-ndowtx"&&(xn.innerHTML=em),de.forEach(t),Ml=n(e),u(Kt.$$.fragment,e),Ll=n(e),ea=i(e,"P",{"data-svelte-h":!0}),c(ea)!=="svelte-1s4vvsz"&&(ea.textContent=tm),Nl=n(e),J=i(e,"DIV",{class:!0});var ot=y(J);u(ta.$$.fragment,ot),Mc=n(ot),wn=i(ot,"P",{"data-svelte-h":!0}),c(wn)!=="svelte-1jb00m3"&&(wn.innerHTML=am),Lc=n(ot),u(st.$$.fragment,ot),ot.forEach(t),Dl=n(e),A=i(e,"DIV",{class:!0});var pe=y(A);u(aa.$$.fragment,pe),Nc=n(pe),Cn=i(pe,"P",{"data-svelte-h":!0}),c(Cn)!=="svelte-1xgprge"&&(Cn.innerHTML=om),Dc=n(pe),u(it.$$.fragment,pe),Uc=n(pe),u(ct.$$.fragment,pe),pe.forEach(t),Ul=n(e),fe=i(e,"DIV",{class:!0});var Ko=y(fe);u(oa.$$.fragment,Ko),jc=n(Ko),Tn=i(Ko,"P",{"data-svelte-h":!0}),c(Tn)!=="svelte-1b6vct0"&&(Tn.innerHTML=nm),Ko.forEach(t),jl=n(e),S=i(e,"DIV",{class:!0});var me=y(S);u(na.$$.fragment,me),Fc=n(me),kn=i(me,"P",{"data-svelte-h":!0}),c(kn)!=="svelte-kb38j6"&&(kn.innerHTML=rm),zc=n(me),u(dt.$$.fragment,me),Ec=n(me),u(pt.$$.fragment,me),me.forEach(t),Fl=n(e),O=i(e,"DIV",{class:!0});var ue=y(O);u(ra.$$.fragment,ue),Ic=n(ue),Pn=i(ue,"P",{"data-svelte-h":!0}),c(Pn)!=="svelte-1y1hln2"&&(Pn.innerHTML=lm),Ac=n(ue),Mn=i(ue,"P",{"data-svelte-h":!0}),c(Mn)!=="svelte-l1d7ay"&&(Mn.innerHTML=sm),Sc=n(ue),u(mt.$$.fragment,ue),ue.forEach(t),zl=n(e),B=i(e,"DIV",{class:!0});var nt=y(B);u(la.$$.fragment,nt),Oc=n(nt),Ln=i(nt,"P",{"data-svelte-h":!0}),c(Ln)!=="svelte-1g1ngcq"&&(Ln.innerHTML=im),Vc=n(nt),ut=i(nt,"DIV",{class:!0});var en=y(ut);u(sa.$$.fragment,en),qc=n(en),Nn=i(en,"P",{"data-svelte-h":!0}),c(Nn)!=="svelte-1iftwh6"&&(Nn.textContent=cm),en.forEach(t),nt.forEach(t),El=n(e),u(ia.$$.fragment,e),Il=n(e),ca=i(e,"P",{"data-svelte-h":!0}),c(ca)!=="svelte-9n5j17"&&(ca.innerHTML=dm),Al=n(e),V=i(e,"DIV",{class:!0});var ge=y(V);u(da.$$.fragment,ge),Rc=n(ge),Dn=i(ge,"P",{"data-svelte-h":!0}),c(Dn)!=="svelte-i90brl"&&(Dn.textContent=pm),Hc=n(ge),gt=i(ge,"DIV",{class:!0});var tn=y(gt);u(pa.$$.fragment,tn),Wc=n(tn),Un=i(tn,"P",{"data-svelte-h":!0}),c(Un)!=="svelte-ht2n4g"&&(Un.textContent=mm),tn.forEach(t),Gc=n(ge),ht=i(ge,"DIV",{class:!0});var _i=y(ht);u(ma.$$.fragment,_i),Jc=n(_i),jn=i(_i,"P",{"data-svelte-h":!0}),c(jn)!=="svelte-19c3yl4"&&(jn.textContent=um),_i.forEach(t),ge.forEach(t),Sl=n(e),L=i(e,"DIV",{class:!0});var G=y(L);u(ua.$$.fragment,G),Bc=n(G),Fn=i(G,"P",{"data-svelte-h":!0}),c(Fn)!=="svelte-da89af"&&(Fn.textContent=gm),Xc=n(G),ft=i(G,"DIV",{class:!0});var bi=y(ft);u(ga.$$.fragment,bi),Zc=n(bi),zn=i(bi,"P",{"data-svelte-h":!0}),c(zn)!=="svelte-1cfoaqn"&&(zn.innerHTML=hm),bi.forEach(t),Yc=n(G),_t=i(G,"DIV",{class:!0});var vi=y(_t);u(ha.$$.fragment,vi),Qc=n(vi),En=i(vi,"P",{"data-svelte-h":!0}),c(En)!=="svelte-1oofbyv"&&(En.textContent=fm),vi.forEach(t),Kc=n(G),bt=i(G,"DIV",{class:!0});var yi=y(bt);u(fa.$$.fragment,yi),ed=n(yi),In=i(yi,"P",{"data-svelte-h":!0}),c(In)!=="svelte-1ugzx3"&&(In.innerHTML=_m),yi.forEach(t),td=n(G),vt=i(G,"DIV",{class:!0});var $i=y(vt);u(_a.$$.fragment,$i),ad=n($i),An=i($i,"P",{"data-svelte-h":!0}),c(An)!=="svelte-w1jkhd"&&(An.textContent=bm),$i.forEach(t),G.forEach(t),Ol=n(e),X=i(e,"DIV",{class:!0});var Kr=y(X);u(ba.$$.fragment,Kr),od=n(Kr),Sn=i(Kr,"P",{"data-svelte-h":!0}),c(Sn)!=="svelte-1gtp5xd"&&(Sn.innerHTML=vm),nd=n(Kr),u(yt.$$.fragment,Kr),Kr.forEach(t),Vl=n(e),_e=i(e,"DIV",{class:!0});var xi=y(_e);u(va.$$.fragment,xi),rd=n(xi),On=i(xi,"P",{"data-svelte-h":!0}),c(On)!=="svelte-51ubws"&&(On.textContent=ym),xi.forEach(t),ql=n(e),be=i(e,"DIV",{class:!0});var wi=y(be);u(ya.$$.fragment,wi),ld=n(wi),Vn=i(wi,"P",{"data-svelte-h":!0}),c(Vn)!=="svelte-1m7chxz"&&(Vn.textContent=$m),wi.forEach(t),Rl=n(e),u($a.$$.fragment,e),Hl=n(e),xa=i(e,"P",{"data-svelte-h":!0}),c(xa)!=="svelte-1tweo9o"&&(xa.textContent=xm),Wl=n(e),ve=i(e,"DIV",{class:!0});var Ci=y(ve);u(wa.$$.fragment,Ci),sd=n(Ci),qn=i(Ci,"P",{"data-svelte-h":!0}),c(qn)!=="svelte-13x39ro"&&(qn.textContent=wm),Ci.forEach(t),Gl=n(e),ye=i(e,"DIV",{class:!0});var Ti=y(ye);u(Ca.$$.fragment,Ti),id=n(Ti),Rn=i(Ti,"P",{"data-svelte-h":!0}),c(Rn)!=="svelte-14x0z8b"&&(Rn.innerHTML=Cm),Ti.forEach(t),Jl=n(e),Z=i(e,"DIV",{class:!0});var el=y(Z);u(Ta.$$.fragment,el),cd=n(el),Hn=i(el,"P",{"data-svelte-h":!0}),c(Hn)!=="svelte-gc8xmf"&&(Hn.textContent=Tm),dd=n(el),$t=i(el,"DIV",{class:!0});var ki=y($t);u(ka.$$.fragment,ki),pd=n(ki),Wn=i(ki,"P",{"data-svelte-h":!0}),c(Wn)!=="svelte-1ujo3ix"&&(Wn.innerHTML=km),ki.forEach(t),el.forEach(t),Bl=n(e),u(Pa.$$.fragment,e),Xl=n(e),Ma=i(e,"P",{"data-svelte-h":!0}),c(Ma)!=="svelte-1shqm9t"&&(Ma.textContent=Pm),Zl=n(e),La=i(e,"UL",{"data-svelte-h":!0}),c(La)!=="svelte-ktow4r"&&(La.innerHTML=Mm),Yl=n(e),u(Na.$$.fragment,e),Ql=n(e),Da=i(e,"P",{"data-svelte-h":!0}),c(Da)!=="svelte-1tvk1lr"&&(Da.innerHTML=Lm),Kl=n(e),$e=i(e,"DIV",{class:!0});var Pi=y($e);u(Ua.$$.fragment,Pi),md=n(Pi),Gn=i(Pi,"P",{"data-svelte-h":!0}),c(Gn)!=="svelte-1nqeor6"&&(Gn.textContent=Nm),Pi.forEach(t),es=n(e),xe=i(e,"DIV",{class:!0});var Mi=y(xe);u(ja.$$.fragment,Mi),ud=n(Mi),Jn=i(Mi,"P",{"data-svelte-h":!0}),c(Jn)!=="svelte-cn5i3a"&&(Jn.textContent=Dm),Mi.forEach(t),ts=n(e),we=i(e,"DIV",{class:!0});var Li=y(we);u(Fa.$$.fragment,Li),gd=n(Li),Bn=i(Li,"P",{"data-svelte-h":!0}),c(Bn)!=="svelte-19z6r9x"&&(Bn.textContent=Um),Li.forEach(t),as=n(e),za=i(e,"DIV",{class:!0});var Wu=y(za);u(Ea.$$.fragment,Wu),Wu.forEach(t),os=n(e),Ce=i(e,"DIV",{class:!0});var Ni=y(Ce);u(Ia.$$.fragment,Ni),hd=n(Ni),Xn=i(Ni,"P",{"data-svelte-h":!0}),c(Xn)!=="svelte-1f5qpw3"&&(Xn.textContent=jm),Ni.forEach(t),ns=n(e),Te=i(e,"DIV",{class:!0});var Di=y(Te);u(Aa.$$.fragment,Di),fd=n(Di),Zn=i(Di,"P",{"data-svelte-h":!0}),c(Zn)!=="svelte-5pai0x"&&(Zn.textContent=Fm),Di.forEach(t),rs=n(e),ke=i(e,"DIV",{class:!0});var Ui=y(ke);u(Sa.$$.fragment,Ui),_d=n(Ui),Yn=i(Ui,"P",{"data-svelte-h":!0}),c(Yn)!=="svelte-11ueuet"&&(Yn.textContent=zm),Ui.forEach(t),ls=n(e),Pe=i(e,"DIV",{class:!0});var ji=y(Pe);u(Oa.$$.fragment,ji),bd=n(ji),Qn=i(ji,"P",{"data-svelte-h":!0}),c(Qn)!=="svelte-kwfglh"&&(Qn.innerHTML=Em),ji.forEach(t),ss=n(e),Me=i(e,"DIV",{class:!0});var Fi=y(Me);u(Va.$$.fragment,Fi),vd=n(Fi),Kn=i(Fi,"P",{"data-svelte-h":!0}),c(Kn)!=="svelte-qjymlr"&&(Kn.textContent=Im),Fi.forEach(t),is=n(e),Le=i(e,"DIV",{class:!0});var zi=y(Le);u(qa.$$.fragment,zi),yd=n(zi),er=i(zi,"P",{"data-svelte-h":!0}),c(er)!=="svelte-l7a6me"&&(er.textContent=Am),zi.forEach(t),cs=n(e),Ne=i(e,"DIV",{class:!0});var Ei=y(Ne);u(Ra.$$.fragment,Ei),$d=n(Ei),tr=i(Ei,"P",{"data-svelte-h":!0}),c(tr)!=="svelte-qzz0oh"&&(tr.textContent=Sm),Ei.forEach(t),ds=n(e),De=i(e,"DIV",{class:!0});var Ii=y(De);u(Ha.$$.fragment,Ii),xd=n(Ii),ar=i(Ii,"P",{"data-svelte-h":!0}),c(ar)!=="svelte-1b3b6xq"&&(ar.textContent=Om),Ii.forEach(t),ps=n(e),Ue=i(e,"DIV",{class:!0});var Ai=y(Ue);u(Wa.$$.fragment,Ai),wd=n(Ai),or=i(Ai,"P",{"data-svelte-h":!0}),c(or)!=="svelte-p9wfl6"&&(or.textContent=Vm),Ai.forEach(t),ms=n(e),je=i(e,"DIV",{class:!0});var Si=y(je);u(Ga.$$.fragment,Si),Cd=n(Si),nr=i(Si,"P",{"data-svelte-h":!0}),c(nr)!=="svelte-2v57ft"&&(nr.textContent=qm),Si.forEach(t),us=n(e),Fe=i(e,"DIV",{class:!0});var Oi=y(Fe);u(Ja.$$.fragment,Oi),Td=n(Oi),rr=i(Oi,"P",{"data-svelte-h":!0}),c(rr)!=="svelte-1hg6hgs"&&(rr.textContent=Rm),Oi.forEach(t),gs=n(e),u(Ba.$$.fragment,e),hs=n(e),Xa=i(e,"P",{"data-svelte-h":!0}),c(Xa)!=="svelte-1vw1u7x"&&(Xa.textContent=Hm),fs=n(e),ze=i(e,"DIV",{class:!0});var Vi=y(ze);u(Za.$$.fragment,Vi),kd=n(Vi),lr=i(Vi,"P",{"data-svelte-h":!0}),c(lr)!=="svelte-pknf9r"&&(lr.textContent=Wm),Vi.forEach(t),_s=n(e),Ee=i(e,"DIV",{class:!0});var qi=y(Ee);u(Ya.$$.fragment,qi),Pd=n(qi),sr=i(qi,"P",{"data-svelte-h":!0}),c(sr)!=="svelte-klpnas"&&(sr.textContent=Gm),qi.forEach(t),bs=n(e),Ie=i(e,"DIV",{class:!0});var Ri=y(Ie);u(Qa.$$.fragment,Ri),Md=n(Ri),ir=i(Ri,"P",{"data-svelte-h":!0}),c(ir)!=="svelte-1hzjle7"&&(ir.textContent=Jm),Ri.forEach(t),vs=n(e),Ae=i(e,"DIV",{class:!0});var Hi=y(Ae);u(Ka.$$.fragment,Hi),Ld=n(Hi),cr=i(Hi,"P",{"data-svelte-h":!0}),c(cr)!=="svelte-1ozj1zv"&&(cr.innerHTML=Bm),Hi.forEach(t),ys=n(e),Se=i(e,"DIV",{class:!0});var Wi=y(Se);u(eo.$$.fragment,Wi),Nd=n(Wi),dr=i(Wi,"P",{"data-svelte-h":!0}),c(dr)!=="svelte-lbejrh"&&(dr.textContent=Xm),Wi.forEach(t),$s=n(e),Oe=i(e,"DIV",{class:!0});var Gi=y(Oe);u(to.$$.fragment,Gi),Dd=n(Gi),pr=i(Gi,"P",{"data-svelte-h":!0}),c(pr)!=="svelte-1ab1a3x"&&(pr.innerHTML=Zm),Gi.forEach(t),xs=n(e),Ve=i(e,"DIV",{class:!0});var Ji=y(Ve);u(ao.$$.fragment,Ji),Ud=n(Ji),mr=i(Ji,"P",{"data-svelte-h":!0}),c(mr)!=="svelte-354jlk"&&(mr.innerHTML=Ym),Ji.forEach(t),ws=n(e),u(oo.$$.fragment,e),Cs=n(e),q=i(e,"DIV",{class:!0});var Dt=y(q);u(no.$$.fragment,Dt),jd=n(Dt),ur=i(Dt,"P",{"data-svelte-h":!0}),c(ur)!=="svelte-1bydad4"&&(ur.innerHTML=Qm),Fd=n(Dt),gr=i(Dt,"P",{"data-svelte-h":!0}),c(gr)!=="svelte-pbl6e"&&(gr.innerHTML=Km),zd=n(Dt),u(xt.$$.fragment,Dt),Dt.forEach(t),Ts=n(e),R=i(e,"DIV",{class:!0});var Ut=y(R);u(ro.$$.fragment,Ut),Ed=n(Ut),hr=i(Ut,"P",{"data-svelte-h":!0}),c(hr)!=="svelte-1orrj43"&&(hr.textContent=eu),Id=n(Ut),fr=i(Ut,"P",{"data-svelte-h":!0}),c(fr)!=="svelte-13444w0"&&(fr.textContent=tu),Ad=n(Ut),u(wt.$$.fragment,Ut),Ut.forEach(t),ks=n(e),qe=i(e,"DIV",{class:!0});var Bi=y(qe);u(lo.$$.fragment,Bi),Sd=n(Bi),_r=i(Bi,"P",{"data-svelte-h":!0}),c(_r)!=="svelte-bn0j3y"&&(_r.textContent=au),Bi.forEach(t),Ps=n(e),so=i(e,"P",{"data-svelte-h":!0}),c(so)!=="svelte-1a2nuzu"&&(so.innerHTML=ou),Ms=n(e),Y=i(e,"DIV",{class:!0});var tl=y(Y);u(io.$$.fragment,tl),Od=n(tl),br=i(tl,"P",{"data-svelte-h":!0}),c(br)!=="svelte-lzv79z"&&(br.textContent=nu),Vd=n(tl),vr=i(tl,"P",{"data-svelte-h":!0}),c(vr)!=="svelte-ygnyji"&&(vr.innerHTML=ru),tl.forEach(t),Ls=n(e),Re=i(e,"DIV",{class:!0});var Xi=y(Re);u(co.$$.fragment,Xi),qd=n(Xi),yr=i(Xi,"P",{"data-svelte-h":!0}),c(yr)!=="svelte-19wz2b5"&&(yr.innerHTML=lu),Xi.forEach(t),Ns=n(e),P=i(e,"DIV",{class:!0});var D=y(P);u(po.$$.fragment,D),Rd=n(D),$r=i(D,"P",{"data-svelte-h":!0}),c($r)!=="svelte-1t4oe8h"&&($r.textContent=su),Hd=n(D),xr=i(D,"P",{"data-svelte-h":!0}),c(xr)!=="svelte-v9orw8"&&(xr.textContent=iu),Wd=n(D),wr=i(D,"P",{"data-svelte-h":!0}),c(wr)!=="svelte-k13j83"&&(wr.textContent=cu),Gd=n(D),Cr=i(D,"P",{"data-svelte-h":!0}),c(Cr)!=="svelte-qx5m51"&&(Cr.textContent=du),Jd=n(D),Tr=i(D,"P",{"data-svelte-h":!0}),c(Tr)!=="svelte-cazsdo"&&(Tr.textContent=pu),Bd=n(D),kr=i(D,"P",{"data-svelte-h":!0}),c(kr)!=="svelte-13iozyc"&&(kr.textContent=mu),D.forEach(t),Ds=n(e),u(mo.$$.fragment,e),Us=n(e),H=i(e,"DIV",{class:!0});var jt=y(H);u(uo.$$.fragment,jt),Xd=n(jt),Pr=i(jt,"P",{"data-svelte-h":!0}),c(Pr)!=="svelte-zhcoft"&&(Pr.innerHTML=uu),Zd=n(jt),Mr=i(jt,"P",{"data-svelte-h":!0}),c(Mr)!=="svelte-1psrnaw"&&(Mr.innerHTML=gu),Yd=n(jt),u(Ct.$$.fragment,jt),jt.forEach(t),js=n(e),u(go.$$.fragment,e),Fs=n(e),ho=i(e,"P",{"data-svelte-h":!0}),c(ho)!=="svelte-bykgas"&&(ho.textContent=hu),zs=n(e),He=i(e,"DIV",{class:!0});var Zi=y(He);u(fo.$$.fragment,Zi),Qd=n(Zi),Lr=i(Zi,"P",{"data-svelte-h":!0}),c(Lr)!=="svelte-ro3mv7"&&(Lr.textContent=fu),Zi.forEach(t),Es=n(e),We=i(e,"DIV",{class:!0});var Yi=y(We);u(_o.$$.fragment,Yi),Kd=n(Yi),Nr=i(Yi,"P",{"data-svelte-h":!0}),c(Nr)!=="svelte-133rrax"&&(Nr.textContent=_u),Yi.forEach(t),Is=n(e),Ge=i(e,"DIV",{class:!0});var Qi=y(Ge);u(bo.$$.fragment,Qi),ep=n(Qi),Dr=i(Qi,"P",{"data-svelte-h":!0}),c(Dr)!=="svelte-6rb454"&&(Dr.textContent=bu),Qi.forEach(t),As=n(e),Q=i(e,"DIV",{class:!0});var al=y(Q);u(vo.$$.fragment,al),tp=n(al),Ur=i(al,"P",{"data-svelte-h":!0}),c(Ur)!=="svelte-15ddhvi"&&(Ur.innerHTML=vu),ap=n(al),u(Tt.$$.fragment,al),al.forEach(t),Ss=n(e),K=i(e,"DIV",{class:!0});var ol=y(K);u(yo.$$.fragment,ol),op=n(ol),jr=i(ol,"P",{"data-svelte-h":!0}),c(jr)!=="svelte-b2jaj7"&&(jr.textContent=yu),np=n(ol),Fr=i(ol,"UL",{"data-svelte-h":!0}),c(Fr)!=="svelte-1l85wx8"&&(Fr.innerHTML=$u),ol.forEach(t),Os=n(e),W=i(e,"DIV",{class:!0});var Ft=y(W);u($o.$$.fragment,Ft),rp=n(Ft),zr=i(Ft,"P",{"data-svelte-h":!0}),c(zr)!=="svelte-ou57jw"&&(zr.textContent=xu),lp=n(Ft),Er=i(Ft,"UL",{"data-svelte-h":!0}),c(Er)!=="svelte-17tb5w2"&&(Er.innerHTML=wu),sp=n(Ft),u(kt.$$.fragment,Ft),Ft.forEach(t),Vs=n(e),ee=i(e,"DIV",{class:!0});var nl=y(ee);u(xo.$$.fragment,nl),ip=n(nl),Ir=i(nl,"P",{"data-svelte-h":!0}),c(Ir)!=="svelte-qft9nv"&&(Ir.textContent=Cu),cp=n(nl),u(Pt.$$.fragment,nl),nl.forEach(t),qs=n(e),Je=i(e,"DIV",{class:!0});var Ki=y(Je);u(wo.$$.fragment,Ki),dp=n(Ki),Ar=i(Ki,"P",{"data-svelte-h":!0}),c(Ar)!=="svelte-aip1s3"&&(Ar.textContent=Tu),Ki.forEach(t),Rs=n(e),Be=i(e,"DIV",{class:!0});var ec=y(Be);u(Co.$$.fragment,ec),pp=n(ec),Sr=i(ec,"P",{"data-svelte-h":!0}),c(Sr)!=="svelte-1eqkbns"&&(Sr.textContent=ku),ec.forEach(t),Hs=n(e),Xe=i(e,"DIV",{class:!0});var tc=y(Xe);u(To.$$.fragment,tc),mp=n(tc),Or=i(tc,"P",{"data-svelte-h":!0}),c(Or)!=="svelte-l4r7eo"&&(Or.textContent=Pu),tc.forEach(t),Ws=n(e),Ze=i(e,"DIV",{class:!0});var ac=y(Ze);u(ko.$$.fragment,ac),up=n(ac),Vr=i(ac,"P",{"data-svelte-h":!0}),c(Vr)!=="svelte-4kdnku"&&(Vr.textContent=Mu),ac.forEach(t),Gs=n(e),Ye=i(e,"DIV",{class:!0});var oc=y(Ye);u(Po.$$.fragment,oc),gp=n(oc),qr=i(oc,"P",{"data-svelte-h":!0}),c(qr)!=="svelte-11wp3c2"&&(qr.innerHTML=Lu),oc.forEach(t),Js=n(e),Qe=i(e,"DIV",{class:!0});var nc=y(Qe);u(Mo.$$.fragment,nc),hp=n(nc),Rr=i(nc,"P",{"data-svelte-h":!0}),c(Rr)!=="svelte-7ujibe"&&(Rr.textContent=Nu),nc.forEach(t),Bs=n(e),u(Lo.$$.fragment,e),Xs=n(e),No=i(e,"P",{"data-svelte-h":!0}),c(No)!=="svelte-hb90k"&&(No.textContent=Du),Zs=n(e),Ke=i(e,"DIV",{class:!0});var rc=y(Ke);u(Do.$$.fragment,rc),fp=n(rc),Hr=i(rc,"P",{"data-svelte-h":!0}),c(Hr)!=="svelte-6rb454"&&(Hr.textContent=Uu),rc.forEach(t),Ys=n(e),et=i(e,"DIV",{class:!0});var lc=y(et);u(Uo.$$.fragment,lc),_p=n(lc),Wr=i(lc,"P",{"data-svelte-h":!0}),c(Wr)!=="svelte-39lvqz"&&(Wr.innerHTML=ju),lc.forEach(t),Qs=n(e),te=i(e,"DIV",{class:!0});var rl=y(te);u(jo.$$.fragment,rl),bp=n(rl),Gr=i(rl,"P",{"data-svelte-h":!0}),c(Gr)!=="svelte-wb8j79"&&(Gr.innerHTML=Fu),vp=n(rl),Jr=i(rl,"P",{"data-svelte-h":!0}),c(Jr)!=="svelte-1cvleir"&&(Jr.textContent=zu),rl.forEach(t),Ks=n(e),ae=i(e,"DIV",{class:!0});var ll=y(ae);u(Fo.$$.fragment,ll),yp=n(ll),Br=i(ll,"P",{"data-svelte-h":!0}),c(Br)!=="svelte-184h98w"&&(Br.textContent=Eu),$p=n(ll),u(Mt.$$.fragment,ll),ll.forEach(t),ei=n(e),u(zo.$$.fragment,e),ti=n(e),Eo=i(e,"P",{"data-svelte-h":!0}),c(Eo)!=="svelte-15rwoxt"&&(Eo.textContent=Iu),ai=n(e),tt=i(e,"DIV",{class:!0});var sc=y(tt);u(Io.$$.fragment,sc),xp=n(sc),Xr=i(sc,"P",{"data-svelte-h":!0}),c(Xr)!=="svelte-1h39mp0"&&(Xr.innerHTML=Au),sc.forEach(t),oi=n(e),Ao=i(e,"DIV",{class:!0});var Gu=y(Ao);u(So.$$.fragment,Gu),Gu.forEach(t),ni=n(e),Oo=i(e,"DIV",{class:!0});var Ju=y(Oo);u(Vo.$$.fragment,Ju),Ju.forEach(t),ri=n(e),u(qo.$$.fragment,e),li=n(e),Ro=i(e,"P",{"data-svelte-h":!0}),c(Ro)!=="svelte-1w7qov1"&&(Ro.textContent=Su),si=n(e),oe=i(e,"DIV",{class:!0});var sl=y(oe);u(Ho.$$.fragment,sl),wp=n(sl),Zr=i(sl,"P",{"data-svelte-h":!0}),c(Zr)!=="svelte-nzrjiz"&&(Zr.innerHTML=Ou),Cp=n(sl),u(Lt.$$.fragment,sl),sl.forEach(t),ii=n(e),u(Wo.$$.fragment,e),ci=n(e),Go=i(e,"P",{"data-svelte-h":!0}),c(Go)!=="svelte-1tfabau"&&(Go.textContent=Vu),di=n(e),ne=i(e,"DIV",{class:!0});var il=y(ne);u(Jo.$$.fragment,il),Tp=n(il),Yr=i(il,"P",{"data-svelte-h":!0}),c(Yr)!=="svelte-qft9nv"&&(Yr.textContent=qu),kp=n(il),u(Nt.$$.fragment,il),il.forEach(t),pi=n(e),u(Bo.$$.fragment,e),mi=n(e),Xo=i(e,"P",{"data-svelte-h":!0}),c(Xo)!=="svelte-10mqezn"&&(Xo.textContent=Ru),ui=n(e),at=i(e,"DIV",{class:!0});var ic=y(at);u(Zo.$$.fragment,ic),Pp=n(ic),Qr=i(ic,"P",{"data-svelte-h":!0}),c(Qr)!=="svelte-1g45l7r"&&(Qr.innerHTML=Hu),ic.forEach(t),gi=n(e),u(Yo.$$.fragment,e),hi=n(e),cl=i(e,"P",{}),y(cl).forEach(t),this.h()},h(){$(d,"name","hf:doc:metadata"),$(d,"content",bg),$(U,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(j,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(F,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(E,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(he,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(I,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(J,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(A,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(fe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(S,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(O,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ut,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(B,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(gt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ht,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(V,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ft,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(_t,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(bt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(vt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(L,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(X,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(_e,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(be,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ve,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ye,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$($t,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$($e,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(xe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(we,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(za,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ce,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Te,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ke,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Pe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Me,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Le,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ne,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(De,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ue,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(je,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Fe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ze,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ee,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ie,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ae,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Se,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Oe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ve,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(q,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(R,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(qe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Y,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Re,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(P,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(H,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(He,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(We,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ge,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Q,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(K,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(W,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ee,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Je,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Be,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Xe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ze,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ye,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Qe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ke,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(et,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(te,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ae,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(tt,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ao,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Oo,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(oe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ne,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(at,"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,a){r(document.head,d),l(e,w,a),l(e,b,a),l(e,v,a),g(C,e,a),l(e,p,a),g(T,e,a),l(e,dl,a),l(e,zt,a),l(e,pl,a),g(Et,e,a),l(e,ml,a),l(e,It,a),l(e,ul,a),l(e,At,a),l(e,gl,a),l(e,St,a),l(e,hl,a),l(e,Ot,a),l(e,fl,a),l(e,Vt,a),l(e,_l,a),g(qt,e,a),l(e,bl,a),l(e,Rt,a),l(e,vl,a),g(Ht,e,a),l(e,yl,a),l(e,Wt,a),l(e,$l,a),l(e,U,a),g(Gt,U,null),r(U,cc),r(U,on),r(U,dc),r(U,nn),r(U,pc),r(U,rn),l(e,xl,a),l(e,j,a),g(Jt,j,null),r(j,mc),r(j,ln),r(j,uc),r(j,sn),r(j,gc),r(j,cn),l(e,wl,a),l(e,F,a),g(Bt,F,null),r(F,hc),r(F,dn),r(F,fc),r(F,pn),r(F,_c),r(F,mn),l(e,Cl,a),l(e,z,a),g(Xt,z,null),r(z,bc),r(z,un),r(z,vc),r(z,gn),r(z,yc),r(z,hn),l(e,Tl,a),l(e,E,a),g(Zt,E,null),r(E,$c),r(E,fn),r(E,xc),r(E,_n),r(E,wc),r(E,bn),l(e,kl,a),l(e,he,a),g(Yt,he,null),r(he,Cc),r(he,vn),l(e,Pl,a),l(e,I,a),g(Qt,I,null),r(I,Tc),r(I,yn),r(I,kc),r(I,$n),r(I,Pc),r(I,xn),l(e,Ml,a),g(Kt,e,a),l(e,Ll,a),l(e,ea,a),l(e,Nl,a),l(e,J,a),g(ta,J,null),r(J,Mc),r(J,wn),r(J,Lc),g(st,J,null),l(e,Dl,a),l(e,A,a),g(aa,A,null),r(A,Nc),r(A,Cn),r(A,Dc),g(it,A,null),r(A,Uc),g(ct,A,null),l(e,Ul,a),l(e,fe,a),g(oa,fe,null),r(fe,jc),r(fe,Tn),l(e,jl,a),l(e,S,a),g(na,S,null),r(S,Fc),r(S,kn),r(S,zc),g(dt,S,null),r(S,Ec),g(pt,S,null),l(e,Fl,a),l(e,O,a),g(ra,O,null),r(O,Ic),r(O,Pn),r(O,Ac),r(O,Mn),r(O,Sc),g(mt,O,null),l(e,zl,a),l(e,B,a),g(la,B,null),r(B,Oc),r(B,Ln),r(B,Vc),r(B,ut),g(sa,ut,null),r(ut,qc),r(ut,Nn),l(e,El,a),g(ia,e,a),l(e,Il,a),l(e,ca,a),l(e,Al,a),l(e,V,a),g(da,V,null),r(V,Rc),r(V,Dn),r(V,Hc),r(V,gt),g(pa,gt,null),r(gt,Wc),r(gt,Un),r(V,Gc),r(V,ht),g(ma,ht,null),r(ht,Jc),r(ht,jn),l(e,Sl,a),l(e,L,a),g(ua,L,null),r(L,Bc),r(L,Fn),r(L,Xc),r(L,ft),g(ga,ft,null),r(ft,Zc),r(ft,zn),r(L,Yc),r(L,_t),g(ha,_t,null),r(_t,Qc),r(_t,En),r(L,Kc),r(L,bt),g(fa,bt,null),r(bt,ed),r(bt,In),r(L,td),r(L,vt),g(_a,vt,null),r(vt,ad),r(vt,An),l(e,Ol,a),l(e,X,a),g(ba,X,null),r(X,od),r(X,Sn),r(X,nd),g(yt,X,null),l(e,Vl,a),l(e,_e,a),g(va,_e,null),r(_e,rd),r(_e,On),l(e,ql,a),l(e,be,a),g(ya,be,null),r(be,ld),r(be,Vn),l(e,Rl,a),g($a,e,a),l(e,Hl,a),l(e,xa,a),l(e,Wl,a),l(e,ve,a),g(wa,ve,null),r(ve,sd),r(ve,qn),l(e,Gl,a),l(e,ye,a),g(Ca,ye,null),r(ye,id),r(ye,Rn),l(e,Jl,a),l(e,Z,a),g(Ta,Z,null),r(Z,cd),r(Z,Hn),r(Z,dd),r(Z,$t),g(ka,$t,null),r($t,pd),r($t,Wn),l(e,Bl,a),g(Pa,e,a),l(e,Xl,a),l(e,Ma,a),l(e,Zl,a),l(e,La,a),l(e,Yl,a),g(Na,e,a),l(e,Ql,a),l(e,Da,a),l(e,Kl,a),l(e,$e,a),g(Ua,$e,null),r($e,md),r($e,Gn),l(e,es,a),l(e,xe,a),g(ja,xe,null),r(xe,ud),r(xe,Jn),l(e,ts,a),l(e,we,a),g(Fa,we,null),r(we,gd),r(we,Bn),l(e,as,a),l(e,za,a),g(Ea,za,null),l(e,os,a),l(e,Ce,a),g(Ia,Ce,null),r(Ce,hd),r(Ce,Xn),l(e,ns,a),l(e,Te,a),g(Aa,Te,null),r(Te,fd),r(Te,Zn),l(e,rs,a),l(e,ke,a),g(Sa,ke,null),r(ke,_d),r(ke,Yn),l(e,ls,a),l(e,Pe,a),g(Oa,Pe,null),r(Pe,bd),r(Pe,Qn),l(e,ss,a),l(e,Me,a),g(Va,Me,null),r(Me,vd),r(Me,Kn),l(e,is,a),l(e,Le,a),g(qa,Le,null),r(Le,yd),r(Le,er),l(e,cs,a),l(e,Ne,a),g(Ra,Ne,null),r(Ne,$d),r(Ne,tr),l(e,ds,a),l(e,De,a),g(Ha,De,null),r(De,xd),r(De,ar),l(e,ps,a),l(e,Ue,a),g(Wa,Ue,null),r(Ue,wd),r(Ue,or),l(e,ms,a),l(e,je,a),g(Ga,je,null),r(je,Cd),r(je,nr),l(e,us,a),l(e,Fe,a),g(Ja,Fe,null),r(Fe,Td),r(Fe,rr),l(e,gs,a),g(Ba,e,a),l(e,hs,a),l(e,Xa,a),l(e,fs,a),l(e,ze,a),g(Za,ze,null),r(ze,kd),r(ze,lr),l(e,_s,a),l(e,Ee,a),g(Ya,Ee,null),r(Ee,Pd),r(Ee,sr),l(e,bs,a),l(e,Ie,a),g(Qa,Ie,null),r(Ie,Md),r(Ie,ir),l(e,vs,a),l(e,Ae,a),g(Ka,Ae,null),r(Ae,Ld),r(Ae,cr),l(e,ys,a),l(e,Se,a),g(eo,Se,null),r(Se,Nd),r(Se,dr),l(e,$s,a),l(e,Oe,a),g(to,Oe,null),r(Oe,Dd),r(Oe,pr),l(e,xs,a),l(e,Ve,a),g(ao,Ve,null),r(Ve,Ud),r(Ve,mr),l(e,ws,a),g(oo,e,a),l(e,Cs,a),l(e,q,a),g(no,q,null),r(q,jd),r(q,ur),r(q,Fd),r(q,gr),r(q,zd),g(xt,q,null),l(e,Ts,a),l(e,R,a),g(ro,R,null),r(R,Ed),r(R,hr),r(R,Id),r(R,fr),r(R,Ad),g(wt,R,null),l(e,ks,a),l(e,qe,a),g(lo,qe,null),r(qe,Sd),r(qe,_r),l(e,Ps,a),l(e,so,a),l(e,Ms,a),l(e,Y,a),g(io,Y,null),r(Y,Od),r(Y,br),r(Y,Vd),r(Y,vr),l(e,Ls,a),l(e,Re,a),g(co,Re,null),r(Re,qd),r(Re,yr),l(e,Ns,a),l(e,P,a),g(po,P,null),r(P,Rd),r(P,$r),r(P,Hd),r(P,xr),r(P,Wd),r(P,wr),r(P,Gd),r(P,Cr),r(P,Jd),r(P,Tr),r(P,Bd),r(P,kr),l(e,Ds,a),g(mo,e,a),l(e,Us,a),l(e,H,a),g(uo,H,null),r(H,Xd),r(H,Pr),r(H,Zd),r(H,Mr),r(H,Yd),g(Ct,H,null),l(e,js,a),g(go,e,a),l(e,Fs,a),l(e,ho,a),l(e,zs,a),l(e,He,a),g(fo,He,null),r(He,Qd),r(He,Lr),l(e,Es,a),l(e,We,a),g(_o,We,null),r(We,Kd),r(We,Nr),l(e,Is,a),l(e,Ge,a),g(bo,Ge,null),r(Ge,ep),r(Ge,Dr),l(e,As,a),l(e,Q,a),g(vo,Q,null),r(Q,tp),r(Q,Ur),r(Q,ap),g(Tt,Q,null),l(e,Ss,a),l(e,K,a),g(yo,K,null),r(K,op),r(K,jr),r(K,np),r(K,Fr),l(e,Os,a),l(e,W,a),g($o,W,null),r(W,rp),r(W,zr),r(W,lp),r(W,Er),r(W,sp),g(kt,W,null),l(e,Vs,a),l(e,ee,a),g(xo,ee,null),r(ee,ip),r(ee,Ir),r(ee,cp),g(Pt,ee,null),l(e,qs,a),l(e,Je,a),g(wo,Je,null),r(Je,dp),r(Je,Ar),l(e,Rs,a),l(e,Be,a),g(Co,Be,null),r(Be,pp),r(Be,Sr),l(e,Hs,a),l(e,Xe,a),g(To,Xe,null),r(Xe,mp),r(Xe,Or),l(e,Ws,a),l(e,Ze,a),g(ko,Ze,null),r(Ze,up),r(Ze,Vr),l(e,Gs,a),l(e,Ye,a),g(Po,Ye,null),r(Ye,gp),r(Ye,qr),l(e,Js,a),l(e,Qe,a),g(Mo,Qe,null),r(Qe,hp),r(Qe,Rr),l(e,Bs,a),g(Lo,e,a),l(e,Xs,a),l(e,No,a),l(e,Zs,a),l(e,Ke,a),g(Do,Ke,null),r(Ke,fp),r(Ke,Hr),l(e,Ys,a),l(e,et,a),g(Uo,et,null),r(et,_p),r(et,Wr),l(e,Qs,a),l(e,te,a),g(jo,te,null),r(te,bp),r(te,Gr),r(te,vp),r(te,Jr),l(e,Ks,a),l(e,ae,a),g(Fo,ae,null),r(ae,yp),r(ae,Br),r(ae,$p),g(Mt,ae,null),l(e,ei,a),g(zo,e,a),l(e,ti,a),l(e,Eo,a),l(e,ai,a),l(e,tt,a),g(Io,tt,null),r(tt,xp),r(tt,Xr),l(e,oi,a),l(e,Ao,a),g(So,Ao,null),l(e,ni,a),l(e,Oo,a),g(Vo,Oo,null),l(e,ri,a),g(qo,e,a),l(e,li,a),l(e,Ro,a),l(e,si,a),l(e,oe,a),g(Ho,oe,null),r(oe,wp),r(oe,Zr),r(oe,Cp),g(Lt,oe,null),l(e,ii,a),g(Wo,e,a),l(e,ci,a),l(e,Go,a),l(e,di,a),l(e,ne,a),g(Jo,ne,null),r(ne,Tp),r(ne,Yr),r(ne,kp),g(Nt,ne,null),l(e,pi,a),g(Bo,e,a),l(e,mi,a),l(e,Xo,a),l(e,ui,a),l(e,at,a),g(Zo,at,null),r(at,Pp),r(at,Qr),l(e,gi,a),g(Yo,e,a),l(e,hi,a),l(e,cl,a),fi=!0},p(e,[a]){const re={};a&2&&(re.$$scope={dirty:a,ctx:e}),st.$set(re);const le={};a&2&&(le.$$scope={dirty:a,ctx:e}),it.$set(le);const se={};a&2&&(se.$$scope={dirty:a,ctx:e}),ct.$set(se);const ie={};a&2&&(ie.$$scope={dirty:a,ctx:e}),dt.$set(ie);const ce={};a&2&&(ce.$$scope={dirty:a,ctx:e}),pt.$set(ce);const Qo={};a&2&&(Qo.$$scope={dirty:a,ctx:e}),mt.$set(Qo);const de={};a&2&&(de.$$scope={dirty:a,ctx:e}),yt.$set(de);const ot={};a&2&&(ot.$$scope={dirty:a,ctx:e}),xt.$set(ot);const pe={};a&2&&(pe.$$scope={dirty:a,ctx:e}),wt.$set(pe);const Ko={};a&2&&(Ko.$$scope={dirty:a,ctx:e}),Ct.$set(Ko);const me={};a&2&&(me.$$scope={dirty:a,ctx:e}),Tt.$set(me);const ue={};a&2&&(ue.$$scope={dirty:a,ctx:e}),kt.$set(ue);const nt={};a&2&&(nt.$$scope={dirty:a,ctx:e}),Pt.$set(nt);const en={};a&2&&(en.$$scope={dirty:a,ctx:e}),Mt.$set(en);const ge={};a&2&&(ge.$$scope={dirty:a,ctx:e}),Lt.$set(ge);const tn={};a&2&&(tn.$$scope={dirty:a,ctx:e}),Nt.$set(tn)},i(e){fi||(h(C.$$.fragment,e),h(T.$$.fragment,e),h(Et.$$.fragment,e),h(qt.$$.fragment,e),h(Ht.$$.fragment,e),h(Gt.$$.fragment,e),h(Jt.$$.fragment,e),h(Bt.$$.fragment,e),h(Xt.$$.fragment,e),h(Zt.$$.fragment,e),h(Yt.$$.fragment,e),h(Qt.$$.fragment,e),h(Kt.$$.fragment,e),h(ta.$$.fragment,e),h(st.$$.fragment,e),h(aa.$$.fragment,e),h(it.$$.fragment,e),h(ct.$$.fragment,e),h(oa.$$.fragment,e),h(na.$$.fragment,e),h(dt.$$.fragment,e),h(pt.$$.fragment,e),h(ra.$$.fragment,e),h(mt.$$.fragment,e),h(la.$$.fragment,e),h(sa.$$.fragment,e),h(ia.$$.fragment,e),h(da.$$.fragment,e),h(pa.$$.fragment,e),h(ma.$$.fragment,e),h(ua.$$.fragment,e),h(ga.$$.fragment,e),h(ha.$$.fragment,e),h(fa.$$.fragment,e),h(_a.$$.fragment,e),h(ba.$$.fragment,e),h(yt.$$.fragment,e),h(va.$$.fragment,e),h(ya.$$.fragment,e),h($a.$$.fragment,e),h(wa.$$.fragment,e),h(Ca.$$.fragment,e),h(Ta.$$.fragment,e),h(ka.$$.fragment,e),h(Pa.$$.fragment,e),h(Na.$$.fragment,e),h(Ua.$$.fragment,e),h(ja.$$.fragment,e),h(Fa.$$.fragment,e),h(Ea.$$.fragment,e),h(Ia.$$.fragment,e),h(Aa.$$.fragment,e),h(Sa.$$.fragment,e),h(Oa.$$.fragment,e),h(Va.$$.fragment,e),h(qa.$$.fragment,e),h(Ra.$$.fragment,e),h(Ha.$$.fragment,e),h(Wa.$$.fragment,e),h(Ga.$$.fragment,e),h(Ja.$$.fragment,e),h(Ba.$$.fragment,e),h(Za.$$.fragment,e),h(Ya.$$.fragment,e),h(Qa.$$.fragment,e),h(Ka.$$.fragment,e),h(eo.$$.fragment,e),h(to.$$.fragment,e),h(ao.$$.fragment,e),h(oo.$$.fragment,e),h(no.$$.fragment,e),h(xt.$$.fragment,e),h(ro.$$.fragment,e),h(wt.$$.fragment,e),h(lo.$$.fragment,e),h(io.$$.fragment,e),h(co.$$.fragment,e),h(po.$$.fragment,e),h(mo.$$.fragment,e),h(uo.$$.fragment,e),h(Ct.$$.fragment,e),h(go.$$.fragment,e),h(fo.$$.fragment,e),h(_o.$$.fragment,e),h(bo.$$.fragment,e),h(vo.$$.fragment,e),h(Tt.$$.fragment,e),h(yo.$$.fragment,e),h($o.$$.fragment,e),h(kt.$$.fragment,e),h(xo.$$.fragment,e),h(Pt.$$.fragment,e),h(wo.$$.fragment,e),h(Co.$$.fragment,e),h(To.$$.fragment,e),h(ko.$$.fragment,e),h(Po.$$.fragment,e),h(Mo.$$.fragment,e),h(Lo.$$.fragment,e),h(Do.$$.fragment,e),h(Uo.$$.fragment,e),h(jo.$$.fragment,e),h(Fo.$$.fragment,e),h(Mt.$$.fragment,e),h(zo.$$.fragment,e),h(Io.$$.fragment,e),h(So.$$.fragment,e),h(Vo.$$.fragment,e),h(qo.$$.fragment,e),h(Ho.$$.fragment,e),h(Lt.$$.fragment,e),h(Wo.$$.fragment,e),h(Jo.$$.fragment,e),h(Nt.$$.fragment,e),h(Bo.$$.fragment,e),h(Zo.$$.fragment,e),h(Yo.$$.fragment,e),fi=!0)},o(e){f(C.$$.fragment,e),f(T.$$.fragment,e),f(Et.$$.fragment,e),f(qt.$$.fragment,e),f(Ht.$$.fragment,e),f(Gt.$$.fragment,e),f(Jt.$$.fragment,e),f(Bt.$$.fragment,e),f(Xt.$$.fragment,e),f(Zt.$$.fragment,e),f(Yt.$$.fragment,e),f(Qt.$$.fragment,e),f(Kt.$$.fragment,e),f(ta.$$.fragment,e),f(st.$$.fragment,e),f(aa.$$.fragment,e),f(it.$$.fragment,e),f(ct.$$.fragment,e),f(oa.$$.fragment,e),f(na.$$.fragment,e),f(dt.$$.fragment,e),f(pt.$$.fragment,e),f(ra.$$.fragment,e),f(mt.$$.fragment,e),f(la.$$.fragment,e),f(sa.$$.fragment,e),f(ia.$$.fragment,e),f(da.$$.fragment,e),f(pa.$$.fragment,e),f(ma.$$.fragment,e),f(ua.$$.fragment,e),f(ga.$$.fragment,e),f(ha.$$.fragment,e),f(fa.$$.fragment,e),f(_a.$$.fragment,e),f(ba.$$.fragment,e),f(yt.$$.fragment,e),f(va.$$.fragment,e),f(ya.$$.fragment,e),f($a.$$.fragment,e),f(wa.$$.fragment,e),f(Ca.$$.fragment,e),f(Ta.$$.fragment,e),f(ka.$$.fragment,e),f(Pa.$$.fragment,e),f(Na.$$.fragment,e),f(Ua.$$.fragment,e),f(ja.$$.fragment,e),f(Fa.$$.fragment,e),f(Ea.$$.fragment,e),f(Ia.$$.fragment,e),f(Aa.$$.fragment,e),f(Sa.$$.fragment,e),f(Oa.$$.fragment,e),f(Va.$$.fragment,e),f(qa.$$.fragment,e),f(Ra.$$.fragment,e),f(Ha.$$.fragment,e),f(Wa.$$.fragment,e),f(Ga.$$.fragment,e),f(Ja.$$.fragment,e),f(Ba.$$.fragment,e),f(Za.$$.fragment,e),f(Ya.$$.fragment,e),f(Qa.$$.fragment,e),f(Ka.$$.fragment,e),f(eo.$$.fragment,e),f(to.$$.fragment,e),f(ao.$$.fragment,e),f(oo.$$.fragment,e),f(no.$$.fragment,e),f(xt.$$.fragment,e),f(ro.$$.fragment,e),f(wt.$$.fragment,e),f(lo.$$.fragment,e),f(io.$$.fragment,e),f(co.$$.fragment,e),f(po.$$.fragment,e),f(mo.$$.fragment,e),f(uo.$$.fragment,e),f(Ct.$$.fragment,e),f(go.$$.fragment,e),f(fo.$$.fragment,e),f(_o.$$.fragment,e),f(bo.$$.fragment,e),f(vo.$$.fragment,e),f(Tt.$$.fragment,e),f(yo.$$.fragment,e),f($o.$$.fragment,e),f(kt.$$.fragment,e),f(xo.$$.fragment,e),f(Pt.$$.fragment,e),f(wo.$$.fragment,e),f(Co.$$.fragment,e),f(To.$$.fragment,e),f(ko.$$.fragment,e),f(Po.$$.fragment,e),f(Mo.$$.fragment,e),f(Lo.$$.fragment,e),f(Do.$$.fragment,e),f(Uo.$$.fragment,e),f(jo.$$.fragment,e),f(Fo.$$.fragment,e),f(Mt.$$.fragment,e),f(zo.$$.fragment,e),f(Io.$$.fragment,e),f(So.$$.fragment,e),f(Vo.$$.fragment,e),f(qo.$$.fragment,e),f(Ho.$$.fragment,e),f(Lt.$$.fragment,e),f(Wo.$$.fragment,e),f(Jo.$$.fragment,e),f(Nt.$$.fragment,e),f(Bo.$$.fragment,e),f(Zo.$$.fragment,e),f(Yo.$$.fragment,e),fi=!1},d(e){e&&(t(w),t(b),t(v),t(p),t(dl),t(zt),t(pl),t(ml),t(It),t(ul),t(At),t(gl),t(St),t(hl),t(Ot),t(fl),t(Vt),t(_l),t(bl),t(Rt),t(vl),t(yl),t(Wt),t($l),t(U),t(xl),t(j),t(wl),t(F),t(Cl),t(z),t(Tl),t(E),t(kl),t(he),t(Pl),t(I),t(Ml),t(Ll),t(ea),t(Nl),t(J),t(Dl),t(A),t(Ul),t(fe),t(jl),t(S),t(Fl),t(O),t(zl),t(B),t(El),t(Il),t(ca),t(Al),t(V),t(Sl),t(L),t(Ol),t(X),t(Vl),t(_e),t(ql),t(be),t(Rl),t(Hl),t(xa),t(Wl),t(ve),t(Gl),t(ye),t(Jl),t(Z),t(Bl),t(Xl),t(Ma),t(Zl),t(La),t(Yl),t(Ql),t(Da),t(Kl),t($e),t(es),t(xe),t(ts),t(we),t(as),t(za),t(os),t(Ce),t(ns),t(Te),t(rs),t(ke),t(ls),t(Pe),t(ss),t(Me),t(is),t(Le),t(cs),t(Ne),t(ds),t(De),t(ps),t(Ue),t(ms),t(je),t(us),t(Fe),t(gs),t(hs),t(Xa),t(fs),t(ze),t(_s),t(Ee),t(bs),t(Ie),t(vs),t(Ae),t(ys),t(Se),t($s),t(Oe),t(xs),t(Ve),t(ws),t(Cs),t(q),t(Ts),t(R),t(ks),t(qe),t(Ps),t(so),t(Ms),t(Y),t(Ls),t(Re),t(Ns),t(P),t(Ds),t(Us),t(H),t(js),t(Fs),t(ho),t(zs),t(He),t(Es),t(We),t(Is),t(Ge),t(As),t(Q),t(Ss),t(K),t(Os),t(W),t(Vs),t(ee),t(qs),t(Je),t(Rs),t(Be),t(Hs),t(Xe),t(Ws),t(Ze),t(Gs),t(Ye),t(Js),t(Qe),t(Bs),t(Xs),t(No),t(Zs),t(Ke),t(Ys),t(et),t(Qs),t(te),t(Ks),t(ae),t(ei),t(ti),t(Eo),t(ai),t(tt),t(oi),t(Ao),t(ni),t(Oo),t(ri),t(li),t(Ro),t(si),t(oe),t(ii),t(ci),t(Go),t(di),t(ne),t(pi),t(mi),t(Xo),t(ui),t(at),t(gi),t(hi),t(cl)),t(d),_(C,e),_(T,e),_(Et,e),_(qt,e),_(Ht,e),_(Gt),_(Jt),_(Bt),_(Xt),_(Zt),_(Yt),_(Qt),_(Kt,e),_(ta),_(st),_(aa),_(it),_(ct),_(oa),_(na),_(dt),_(pt),_(ra),_(mt),_(la),_(sa),_(ia,e),_(da),_(pa),_(ma),_(ua),_(ga),_(ha),_(fa),_(_a),_(ba),_(yt),_(va),_(ya),_($a,e),_(wa),_(Ca),_(Ta),_(ka),_(Pa,e),_(Na,e),_(Ua),_(ja),_(Fa),_(Ea),_(Ia),_(Aa),_(Sa),_(Oa),_(Va),_(qa),_(Ra),_(Ha),_(Wa),_(Ga),_(Ja),_(Ba,e),_(Za),_(Ya),_(Qa),_(Ka),_(eo),_(to),_(ao),_(oo,e),_(no),_(xt),_(ro),_(wt),_(lo),_(io),_(co),_(po),_(mo,e),_(uo),_(Ct),_(go,e),_(fo),_(_o),_(bo),_(vo),_(Tt),_(yo),_($o),_(kt),_(xo),_(Pt),_(wo),_(Co),_(To),_(ko),_(Po),_(Mo),_(Lo,e),_(Do),_(Uo),_(jo),_(Fo),_(Mt),_(zo,e),_(Io),_(So),_(Vo),_(qo,e),_(Ho),_(Lt),_(Wo,e),_(Jo),_(Nt),_(Bo,e),_(Zo),_(Yo,e)}}}const bg='{"title":"Utility functions and classes","local":"utility-functions-and-classes","sections":[{"title":"Constants","local":"constants","sections":[],"depth":2},{"title":"Data Classes","local":"data-classes","sections":[{"title":"Standalone","local":"accelerate.utils.ComputeEnvironment","sections":[],"depth":3},{"title":"Kwargs","local":"accelerate.AutocastKwargs","sections":[],"depth":3}],"depth":2},{"title":"Plugins","local":"accelerate.DeepSpeedPlugin","sections":[],"depth":2},{"title":"Configurations","local":"accelerate.utils.BnbQuantizationConfig","sections":[],"depth":2},{"title":"Environmental Variables","local":"environmental-variables","sections":[],"depth":2},{"title":"Data Manipulation and Operations","local":"accelerate.utils.broadcast","sections":[],"depth":2},{"title":"Environment Checks","local":"accelerate.utils.is_bf16_available","sections":[],"depth":2},{"title":"Environment Manipulation","local":"accelerate.utils.patch_environment","sections":[],"depth":2},{"title":"Memory","local":"accelerate.find_executable_batch_size","sections":[],"depth":2},{"title":"Modeling","local":"accelerate.utils.calculate_maximum_sizes","sections":[],"depth":2},{"title":"Parallel","local":"accelerate.utils.extract_model_from_parallel","sections":[],"depth":2},{"title":"Random","local":"accelerate.utils.set_seed","sections":[],"depth":2},{"title":"PyTorch XLA","local":"accelerate.utils.install_xla","sections":[],"depth":2},{"title":"Loading model weights","local":"accelerate.load_checkpoint_in_model","sections":[],"depth":2},{"title":"Quantization","local":"accelerate.utils.load_and_quantize_model","sections":[],"depth":2}],"depth":1}';function vg(k){return Xu(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class Pg extends Zu{constructor(d){super(),Yu(this,d,vg,_g,Bu,{})}}export{Pg as component};
