Buckets:

HuggingFaceDocBuilder's picture
download
raw
21.4 kB
import"../chunks/DsnmJJEf.js";import{i as fe,h as _e,C as ve,H as o,D as r,E as be,s as ye,a as O}from"../chunks/D6eQvJIN.js";import{p as ke,o as we,s as e,f as J,a as l,b as Te,c as t,d as c,n as a,r as n}from"../chunks/D9TCMYxZ.js";import{E as Q}from"../chunks/D8azpo8f.js";const xe='{"title":"Custom layers and utilities","local":"custom-layers-and-utilities","sections":[{"title":"WeightRenaming","local":"transformers.GroupWeightRename","sections":[],"depth":2},{"title":"WeightConverter","local":"transformers.WeightConverter","sections":[{"title":"Conversion operations","local":"transformers.ConversionOps","sections":[],"depth":3}],"depth":2},{"title":"Layers","local":"transformers.GradientCheckpointingLayer","sections":[],"depth":2},{"title":"Attention Functions","local":"transformers.AttentionInterface","sections":[],"depth":2},{"title":"Attention Mask Functions","local":"transformers.AttentionMaskInterface","sections":[],"depth":2},{"title":"Rotary Position Embedding Functions","local":"transformers.dynamic_rope_update","sections":[],"depth":2},{"title":"Pytorch custom modules","local":"transformers.Conv1D","sections":[],"depth":2},{"title":"PyTorch Helper Functions","local":"transformers.apply_chunking_to_forward","sections":[],"depth":2}],"depth":1}';var Me=c('<meta name="hf:doc:metadata"/>'),Ce=c("<p>Example:</p> <!>",1),Ge=c("<p>Examples:</p> <!>",1),Re=c(`<p></p> <!> <!> <p>This page lists all the custom layers used by the library, as well as the utility functions and classes it provides for modeling.</p> <p>Most of those are only useful if you are studying the code of the models in the library.</p> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Applies a list of paired WeightRenaming transforms, activated lazily by the first (“guard”)
source pattern. Use this when two renames share an intermediate name (e.g. <code>norm0→norm1</code> and <code>norm1→norm2</code>) so that loading an already-converted checkpoint (which has <code>norm1</code> and <code>norm2</code> but no <code>norm0</code>) does not incorrectly re-apply the renames.</p> <p>NOTE: order <code>source_patterns</code> so that the one that is absent in an already-converted checkpoint
comes first. The state dict is iterated in sorted key order, so the guard pattern must be
lexicographically smaller than the dependent patterns. Otherwise the dependents will be
skipped on the first pass and never retried.</p></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Base class for weight conversion operations.</p></div> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Split a tensor along <code>dim</code> into equally sized chunks. Additionally, <code>num_shards_attribute</code> is a config field to read
to know how many tensors to chunk into. Useful when concatenating an arbitrary number of tensors.</p></div> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Concatenate tensors along <code>dim</code>. Additionally, if concatenating an aribitrary number of tensors, <code>num_shards_attribute</code> is
a config field to read to know how many tensors to recreate when using the opposite Ops.</p></div> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Merge a list of tensors into a single tensor along the first dimension.
We explicitly define this because for EP or TP you want to make sure you know what you are doing!</p></div> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Inverse of <code>MergeModulelist</code> using explicit split sizes per group.</p></div> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Applies the permutation required to convert complex RoPE weights to the split sin/cos format.</p></div> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Applies the permutation required to convert complex RoPE weights to the split sin/cos format on fused QKV.
Same as calling <code>PermuteForRope() + Concatenate()</code> but lets us call <code>Permute</code> only on a subset of chunked tensors.</p> <p>NOTE: this conversion applies only to a vision backbone in multimodal models, because it checks <code>config.vision_config</code></p></div> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Applies the permutation required to convert complex RoPE weights to the split sin/cos format on fused QKV.
Same as calling <code>Chunk() + PermuteForRope()</code> but lets us call <code>Permute</code> only on a subset of chunked tensors.</p> <p>NOTE: this conversion applies only to a vision backbone in multimodal models, because it checks <code>config.vision_config</code></p></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Base class for layers with gradient checkpointing.</p> <p>This class enables gradient checkpointing functionality for a layer. By default, gradient checkpointing is disabled
(<code>gradient_checkpointing = False</code>). When <code>model.set_gradient_checkpointing()</code> is called, gradient checkpointing is
enabled by setting <code>gradient_checkpointing = True</code> and assigning a checkpointing function to <code>_gradient_checkpointing_func</code>.</p> <p>Important:</p> <p>When using gradient checkpointing with <code>use_reentrant=True</code>, inputs that require gradients (e.g. hidden states)
must be passed as positional arguments (<code>*args</code>) rather than keyword arguments to properly propagate gradients.</p> <!></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Dict-like object keeping track of allowed attention functions. You can easily add a new attention function
with a call to <code>register()</code>. If a model needs to locally overwrite an existing attention function, say <code>sdpa</code>,
it needs to declare a new instance of this class inside the <code>modeling_&lt;model&gt;.py</code>, and declare it on that instance.</p> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!></div></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!></div></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Decorator function to update the RoPE parameters in the forward pass, if the model is using a dynamic RoPE
(i.e. a RoPE implementation that may recompute its frequencies in the forward pass).</p></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>1D-convolutional layer as defined by Radford et al. for OpenAI GPT (and also used in GPT-2).</p> <p>Basically works like a linear layer but the weights are transposed.</p></div> <!> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>This function chunks the <code>input_tensors</code> into smaller input tensor parts of size <code>chunk_size</code> over the dimension <code>chunk_dim</code>. It then applies a layer <code>forward_fn</code> to each chunk independently to save memory.</p> <p>If the <code>forward_fn</code> is independent across the <code>chunk_dim</code> this function will yield the same result as directly
applying <code>forward_fn</code> to <code>input_tensors</code>.</p> <!></div> <div class="docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"><!> <p>Prune a linear layer to keep only entries in index.</p> <p>Used to remove heads.</p></div> <!> <p></p>`,1);function Fe(S,q){ke(q,!1),we(()=>{new URLSearchParams(window.location.search).get("fw")}),fe();var j=Re();_e("1li5ozk",s=>{var d=Me();ye(d,"content",xe),l(s,d)});var I=e(J(j),2);ve(I,{containerStyle:"float: right; margin-left: 10px; display: inline-flex; position: relative; z-index: 10;"});var Z=e(I,2);o(Z,{title:"Custom layers and utilities",local:"custom-layers-and-utilities",headingTag:"h1"});var F=e(Z,6);o(F,{title:"WeightRenaming",local:"transformers.GroupWeightRename",headingTag:"h2"});var p=e(F,2),$=t(p);r($,{name:"class transformers.GroupWeightRename",anchor:"transformers.GroupWeightRename",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/core_model_loading.py#L1032",parameters:[{name:"source_patterns",val:": list[str]"},{name:"target_patterns",val:": list[str]"}]}),a(4),n(p);var V=e(p,2);o(V,{title:"WeightConverter",local:"transformers.WeightConverter",headingTag:"h2"});var m=e(V,2),K=t(m);r(K,{name:"class transformers.WeightConverter",anchor:"transformers.WeightConverter",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/core_model_loading.py#L1152",parameters:[{name:"source_patterns",val:": str | list[str]"},{name:"target_patterns",val:": str | list[str]"},{name:"operations",val:": list[ConversionOps]"},{name:"force_cpu",val:": bool = False"}]}),n(m);var W=e(m,2);o(W,{title:"Conversion operations",local:"transformers.ConversionOps",headingTag:"h3"});var h=e(W,2),ee=t(h);r(ee,{name:"class transformers.ConversionOps",anchor:"transformers.ConversionOps",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/core_model_loading.py#L81",parameters:[]}),a(2),n(h);var u=e(h,2),re=t(u);r(re,{name:"class transformers.Chunk",anchor:"transformers.Chunk",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/core_model_loading.py#L112",parameters:[{name:"dim",val:": int = 0"},{name:"num_shards_attribute",val:": str | None = None"}]}),a(2),n(u);var g=e(u,2),te=t(g);r(te,{name:"class transformers.Concatenate",anchor:"transformers.Concatenate",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/core_model_loading.py#L150",parameters:[{name:"dim",val:": int = 0"},{name:"num_shards_attribute",val:": str | None = None"}]}),a(2),n(g);var f=e(g,2),ne=t(f);r(ne,{name:"class transformers.MergeModulelist",anchor:"transformers.MergeModulelist",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/core_model_loading.py#L222",parameters:[{name:"dim",val:": int = 0"}]}),a(2),n(f);var _=e(f,2),ae=t(_);r(ae,{name:"class transformers.SplitModulelist",anchor:"transformers.SplitModulelist",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/core_model_loading.py#L273",parameters:[{name:"dim",val:": int = 0"}]}),a(2),n(_);var v=e(_,2),oe=t(v);r(oe,{name:"class transformers.PermuteForRope",anchor:"transformers.PermuteForRope",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/core_model_loading.py#L428",parameters:[{name:"subconfig_key",val:": str | None = None"},{name:"permute_layer_names",val:": list[str] | None = None"},{name:"inverse",val:": bool = False"}]}),a(2),n(v);var b=e(v,2),se=t(b);r(se,{name:"class transformers.VisionFuseAndPermuteForRope",anchor:"transformers.VisionFuseAndPermuteForRope",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/core_model_loading.py#L488",parameters:[{name:"dim",val:": int = 0"},{name:"permute_layer_names",val:": list[str] | None = None"},{name:"inverse",val:": bool = True"}]}),a(4),n(b);var y=e(b,2),ie=t(y);r(ie,{name:"class transformers.VisionUnfuseAndPermuteForRope",anchor:"transformers.VisionUnfuseAndPermuteForRope",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/core_model_loading.py#L542",parameters:[{name:"dim",val:": int = 0"},{name:"permute_layer_names",val:": list[str] | None = None"},{name:"inverse",val:": bool = False"}]}),a(4),n(y);var L=e(y,2);o(L,{title:"Layers",local:"transformers.GradientCheckpointingLayer",headingTag:"h2"});var k=e(L,2),A=t(k);r(A,{name:"class transformers.GradientCheckpointingLayer",anchor:"transformers.GradientCheckpointingLayer",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/modeling_layers.py#L53",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}]});var de=e(A,10);Q(de,{anchor:"transformers.GradientCheckpointingLayer.example",children:(s,d)=>{var i=Ce(),R=e(J(i),2);O(R,{code:"JTIzJTIwQ29ycmVjdCUyMC0lMjBoaWRkZW5fc3RhdGVzJTIwcGFzc2VkJTIwYXMlMjBwb3NpdGlvbmFsJTIwYXJnJTBBb3V0JTIwJTNEJTIwc2VsZi5sYXllcihoaWRkZW5fc3RhdGVzJTJDJTIwYXR0ZW50aW9uX21hc2slM0RhdHRlbnRpb25fbWFzayklMEElMEElMjMlMjBJbmNvcnJlY3QlMjAtJTIwaGlkZGVuX3N0YXRlcyUyMHBhc3NlZCUyMGFzJTIwa2V5d29yZCUyMGFyZyUwQW91dCUyMCUzRCUyMHNlbGYubGF5ZXIoaGlkZGVuX3N0YXRlcyUzRGhpZGRlbl9zdGF0ZXMlMkMlMjBhdHRlbnRpb25fbWFzayUzRGF0dGVudGlvbl9tYXNrKQ==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Correct - hidden_states passed as positional arg</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>out = <span class="hljs-variable language_">self</span>.layer(hidden_states, attention_mask=attention_mask)
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Incorrect - hidden_states passed as keyword arg</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>out = <span class="hljs-variable language_">self</span>.layer(hidden_states=hidden_states, attention_mask=attention_mask)`,lang:"python",wrap:!1}),l(s,i)},$$slots:{default:!0}}),n(k);var P=e(k,2);o(P,{title:"Attention Functions",local:"transformers.AttentionInterface",headingTag:"h2"});var w=e(P,2),z=t(w);r(z,{name:"class transformers.AttentionInterface",anchor:"transformers.AttentionInterface",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/modeling_utils.py#L5109",parameters:[]});var E=e(z,4),le=t(E);r(le,{name:"register",anchor:"transformers.AttentionInterface.register",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/utils/generic.py#L1143",parameters:[{name:"key",val:": str"},{name:"value",val:": Callable"}]}),n(E),n(w);var N=e(w,2);o(N,{title:"Attention Mask Functions",local:"transformers.AttentionMaskInterface",headingTag:"h2"});var T=e(N,2),U=t(T);r(U,{name:"class transformers.AttentionMaskInterface",anchor:"transformers.AttentionMaskInterface",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/masking_utils.py#L717",parameters:[]});var X=e(U,2),ce=t(X);r(ce,{name:"register",anchor:"transformers.AttentionMaskInterface.register",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/utils/generic.py#L1143",parameters:[{name:"key",val:": str"},{name:"value",val:": Callable"}]}),n(X),n(T);var B=e(T,2);o(B,{title:"Rotary Position Embedding Functions",local:"transformers.dynamic_rope_update",headingTag:"h2"});var x=e(B,2),pe=t(x);r(pe,{name:"transformers.dynamic_rope_update",anchor:"transformers.dynamic_rope_update",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/modeling_rope_utils.py#L34",parameters:[{name:"rope_forward",val:""}],parametersDescription:[{anchor:"transformers.dynamic_rope_update.rope_forward",description:`<strong>rope_forward</strong> (Callable) &#x2014;
The forward pass of the RoPE implementation.`,name:"rope_forward"}],returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>
<p>The decorated forward pass.</p>
`}),a(2),n(x);var D=e(x,2);o(D,{title:"Pytorch custom modules",local:"transformers.Conv1D",headingTag:"h2"});var M=e(D,2),me=t(M);r(me,{name:"class transformers.Conv1D",anchor:"transformers.Conv1D",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/pytorch_utils.py#L95",parameters:[{name:"nf",val:""},{name:"nx",val:""}],parametersDescription:[{anchor:"transformers.Conv1D.nf",description:"<strong>nf</strong> (<code>int</code>) &#x2014; The number of output features.",name:"nf"},{anchor:"transformers.Conv1D.nx",description:"<strong>nx</strong> (<code>int</code>) &#x2014; The number of input features.",name:"nx"}]}),a(4),n(M);var Y=e(M,2);o(Y,{title:"PyTorch Helper Functions",local:"transformers.apply_chunking_to_forward",headingTag:"h2"});var C=e(Y,2),H=t(C);r(H,{name:"transformers.apply_chunking_to_forward",anchor:"transformers.apply_chunking_to_forward",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/pytorch_utils.py#L124",parameters:[{name:"forward_fn",val:": Callable[..., torch.Tensor]"},{name:"chunk_size",val:": int"},{name:"chunk_dim",val:": int"},{name:"*input_tensors",val:""}],parametersDescription:[{anchor:"transformers.apply_chunking_to_forward.forward_fn",description:`<strong>forward_fn</strong> (<code>Callable[..., torch.Tensor]</code>) &#x2014;
The forward function of the model.`,name:"forward_fn"},{anchor:"transformers.apply_chunking_to_forward.chunk_size",description:`<strong>chunk_size</strong> (<code>int</code>) &#x2014;
The chunk size of a chunked tensor: <code>num_chunks = len(input_tensors[0]) / chunk_size</code>.`,name:"chunk_size"},{anchor:"transformers.apply_chunking_to_forward.chunk_dim",description:`<strong>chunk_dim</strong> (<code>int</code>) &#x2014;
The dimension over which the <code>input_tensors</code> should be chunked.`,name:"chunk_dim"},{anchor:"transformers.apply_chunking_to_forward.input_tensors",description:`<strong>input_tensors</strong> (<code>tuple[torch.Tensor]</code>) &#x2014;
The input tensors of <code>forward_fn</code> which will be chunked`,name:"input_tensors"}],returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>
<p>A tensor with the same shape as the <code>forward_fn</code> would have given if applied\`.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>
<p><code>torch.Tensor</code></p>
`});var he=e(H,6);Q(he,{anchor:"transformers.apply_chunking_to_forward.example",children:(s,d)=>{var i=Ge(),R=e(J(i),2);O(R,{code:"JTIzJTIwcmVuYW1lJTIwdGhlJTIwdXN1YWwlMjBmb3J3YXJkKCklMjBmbiUyMHRvJTIwZm9yd2FyZF9jaHVuaygpJTBBZGVmJTIwZm9yd2FyZF9jaHVuayhzZWxmJTJDJTIwaGlkZGVuX3N0YXRlcyklM0ElMEElMjAlMjAlMjAlMjBoaWRkZW5fc3RhdGVzJTIwJTNEJTIwc2VsZi5kZWNvZGVyKGhpZGRlbl9zdGF0ZXMpJTBBJTIwJTIwJTIwJTIwcmV0dXJuJTIwaGlkZGVuX3N0YXRlcyUwQSUwQSUwQSUyMyUyMGltcGxlbWVudCUyMGElMjBjaHVua2VkJTIwZm9yd2FyZCUyMGZ1bmN0aW9uJTBBZGVmJTIwZm9yd2FyZChzZWxmJTJDJTIwaGlkZGVuX3N0YXRlcyklM0ElMEElMjAlMjAlMjAlMjByZXR1cm4lMjBhcHBseV9jaHVua2luZ190b19mb3J3YXJkKHNlbGYuZm9yd2FyZF9jaHVuayUyQyUyMHNlbGYuY2h1bmtfc2l6ZV9sbV9oZWFkJTJDJTIwc2VsZi5zZXFfbGVuX2RpbSUyQyUyMGhpZGRlbl9zdGF0ZXMp",highlighted:`<span class="hljs-comment"># rename the usual forward() fn to forward_chunk()</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">forward_chunk</span>(<span class="hljs-params">self, hidden_states</span>):
hidden_states = <span class="hljs-variable language_">self</span>.decoder(hidden_states)
<span class="hljs-keyword">return</span> hidden_states
<span class="hljs-comment"># implement a chunked forward function</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">forward</span>(<span class="hljs-params">self, hidden_states</span>):
<span class="hljs-keyword">return</span> apply_chunking_to_forward(<span class="hljs-variable language_">self</span>.forward_chunk, <span class="hljs-variable language_">self</span>.chunk_size_lm_head, <span class="hljs-variable language_">self</span>.seq_len_dim, hidden_states)`,lang:"python",wrap:!1}),l(s,i)},$$slots:{default:!0}}),n(C);var G=e(C,2),ue=t(G);r(ue,{name:"transformers.pytorch_utils.prune_linear_layer",anchor:"transformers.pytorch_utils.prune_linear_layer",source:"https://github.com/huggingface/transformers/blob/vr_43265/src/transformers/pytorch_utils.py#L61",parameters:[{name:"layer",val:": nn.Linear"},{name:"index",val:": torch.LongTensor"},{name:"dim",val:": int = 0"}],parametersDescription:[{anchor:"transformers.pytorch_utils.prune_linear_layer.layer",description:"<strong>layer</strong> (<code>torch.nn.Linear</code>) &#x2014; The layer to prune.",name:"layer"},{anchor:"transformers.pytorch_utils.prune_linear_layer.index",description:"<strong>index</strong> (<code>torch.LongTensor</code>) &#x2014; The indices to keep in the layer.",name:"index"},{anchor:"transformers.pytorch_utils.prune_linear_layer.dim",description:"<strong>dim</strong> (<code>int</code>, <em>optional</em>, defaults to 0) &#x2014; The dimension on which to keep the indices.",name:"dim"}],returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>
<p>The pruned layer as a new layer with <code>requires_grad=True</code>.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>
<p><code>torch.nn.Linear</code></p>
`}),a(4),n(G);var ge=e(G,2);be(ge,{source:"https://github.com/huggingface/transformers/blob/main/docs/source/en/internal/modeling_utils.md"}),a(2),l(S,j),Te()}export{Fe as component};

Xet Storage Details

Size:
21.4 kB
·
Xet hash:
15e1da9f0cc9ba70f00e4f45e1958c7ea652df7aaa5ee213d3410503863879c2

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.