import{s as fn,f as gn,o as _n,n as yt}from"../chunks/scheduler.25b97de1.js";import{S as bn,i as yn,g as i,s as a,r as p,A as vn,h as d,f as n,c as s,j as W,u,x as c,k as Z,y as l,a as o,v as h,d as f,t as g,w as _}from"../chunks/index.d9030fc9.js";import{T as Nt}from"../chunks/Tip.baa67368.js";import{D as Me}from"../chunks/Docstring.ffac8efa.js";import{C as bt}from"../chunks/CodeBlock.e6cd0d95.js";import{E as kn}from"../chunks/ExampleCodeBlock.22dfe688.js";import{H as x,E as Tn}from"../chunks/EditOnGithub.91d95064.js";function Mn(F){let r,k=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code>
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`;return{c(){r=i("p"),r.innerHTML=k},l(m){r=d(m,"P",{"data-svelte-h":!0}),c(r)!=="svelte-fincs2"&&(r.innerHTML=k)},m(m,v){o(m,r,v)},p:yt,d(m){m&&n(r)}}}function $n(F){let r,k=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code>
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`;return{c(){r=i("p"),r.innerHTML=k},l(m){r=d(m,"P",{"data-svelte-h":!0}),c(r)!=="svelte-fincs2"&&(r.innerHTML=k)},m(m,v){o(m,r,v)},p:yt,d(m){m&&n(r)}}}function wn(F){let r,k="Example:",m,v,C;return v=new bt({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Ub2tlbml6ZXIlMkMlMjBaYW1iYUZvckNhdXNhbExNJTBBJTBBbW9kZWwlMjAlM0QlMjBaYW1iYUZvckNhdXNhbExNLmZyb21fcHJldHJhaW5lZCglMjJaeXBocmElMkZaYW1iYS03Qi12MSUyMiklMEF0b2tlbml6ZXIlMjAlM0QlMjBBdXRvVG9rZW5pemVyLmZyb21fcHJldHJhaW5lZCglMjJaeXBocmElMkZaYW1iYS03Qi12MSUyMiklMEElMEFwcm9tcHQlMjAlM0QlMjAlMjJIZXklMkMlMjBhcmUlMjB5b3UlMjBjb25zY2lvdXMlM0YlMjBDYW4lMjB5b3UlMjB0YWxrJTIwdG8lMjBtZSUzRiUyMiUwQWlucHV0cyUyMCUzRCUyMHRva2VuaXplcihwcm9tcHQlMkMlMjByZXR1cm5fdGVuc29ycyUzRCUyMnB0JTIyKSUwQSUwQSUyMyUyMEdlbmVyYXRlJTBBZ2VuZXJhdGVfaWRzJTIwJTNEJTIwbW9kZWwuZ2VuZXJhdGUoaW5wdXRzLmlucHV0X2lkcyUyQyUyMG1heF9sZW5ndGglM0QzMCklMEF0b2tlbml6ZXIuYmF0Y2hfZGVjb2RlKGdlbmVyYXRlX2lkcyUyQyUyMHNraXBfc3BlY2lhbF90b2tlbnMlM0RUcnVlJTJDJTIwY2xlYW5fdXBfdG9rZW5pemF0aW9uX3NwYWNlcyUzREZhbHNlKSU1QjAlNUQ=",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, ZambaForCausalLM

<span class="hljs-meta">&gt;&gt;&gt; </span>model = ZambaForCausalLM.from_pretrained(<span class="hljs-string">&quot;Zyphra/Zamba-7B-v1&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;Zyphra/Zamba-7B-v1&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span>prompt = <span class="hljs-string">&quot;Hey, are you conscious? Can you talk to me?&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(prompt, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>)

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Generate</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>generate_ids = model.generate(inputs.input_ids, max_length=<span class="hljs-number">30</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer.batch_decode(generate_ids, skip_special_tokens=<span class="hljs-literal">True</span>, clean_up_tokenization_spaces=<span class="hljs-literal">False</span>)[<span class="hljs-number">0</span>]
<span class="hljs-string">&quot;Hey, are you conscious? Can you talk to me?\\nI&#x27;m not conscious, but I can talk to you.&quot;</span>`,wrap:!1}}),{c(){r=i("p"),r.textContent=k,m=a(),p(v.$$.fragment)},l(b){r=d(b,"P",{"data-svelte-h":!0}),c(r)!=="svelte-11lpom8"&&(r.textContent=k),m=s(b),u(v.$$.fragment,b)},m(b,L){o(b,r,L),o(b,m,L),h(v,b,L),C=!0},p:yt,i(b){C||(f(v.$$.fragment,b),C=!0)},o(b){g(v.$$.fragment,b),C=!1},d(b){b&&(n(r),n(m)),_(v,b)}}}function Cn(F){let r,k=`Although the recipe for forward pass needs to be defined within this function, one should call the <code>Module</code>
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`;return{c(){r=i("p"),r.innerHTML=k},l(m){r=d(m,"P",{"data-svelte-h":!0}),c(r)!=="svelte-fincs2"&&(r.innerHTML=k)},m(m,v){o(m,r,v)},p:yt,d(m){m&&n(r)}}}function zn(F){let r,k,m,v,C,b,L,St='Zamba is a large language model (LLM) trained by Zyphra, and made available under an Apache 2.0 license. Please see the <a href="https://huggingface.co/collections/zyphra/" rel="nofollow">Zyphra Hugging Face</a> repository for model weights.',Ae,D,Jt='This model was contributed by <a href="https://huggingface.co/pglo" rel="nofollow">pglo</a>.',Ne,O,Se,X,Dt='Zamba-7B-v1 is a hybrid between state-space models (Specifically <a href="https://github.com/state-spaces/mamba" rel="nofollow">Mamba</a>) and transformer, and was trained using next-token prediction. Zamba uses a shared transformer layer after every 6 mamba blocks. It uses the <a href="https://huggingface.co/mistralai/Mistral-7B-v0.1" rel="nofollow">Mistral v0.1 tokenizer</a>. We came to this architecture after a series of ablations at small scales. Zamba-7B-v1 was pre-trained on 1T tokens of text and code data.',Je,B,Ot,De,E,Oe,R,Xe,G,Xt="Zamba requires you use <code>transformers</code> version 4.46.0 or higher:",Ee,V,Re,Y,Et="In order to run optimized Mamba implementations, you first need to install <code>mamba-ssm</code> and <code>causal-conv1d</code>:",Ge,Q,Ve,K,Rt="You also have to have the model on a CUDA device.",Ye,ee,Gt="You can run the model not using the optimized Mamba kernels, but it is <strong>not</strong> recommended as it will result in significantly lower latencies. In order to do that, you’ll need to specify <code>use_mamba_kernels=False</code> when loading the model.",Qe,te,Ke,ne,et,oe,tt,ae,Vt="The model cards can be found at:",nt,se,Yt='<li><a href="MODEL_CARD_ZAMBA-7B-v1.md">Zamba-7B</a></li>',ot,re,at,ie,Qt='For issues with model output, or community discussion, please use the Hugging Face community <a href="https://huggingface.co/zyphra/zamba-7b" rel="nofollow">forum</a>',st,de,rt,le,Kt="The model weights are open-sourced via an Apache 2.0 license.",it,ce,dt,$,me,vt,$e,en=`This is the configuration class to store the configuration of a <a href="/docs/transformers/main/en/model_doc/zamba#transformers.ZambaModel">ZambaModel</a>. It is used to instantiate a
Zamba model according to the specified arguments, defining the model architecture. Instantiating a configuration
with the defaults will yield a similar configuration to that of the Zamba-v0.1 model.`,kt,we,tn='<a href="https://huggingface.co/Zyphra/Zamba-7B-v1" rel="nofollow">Zyphra/Zamba-7B-v1</a>',Tt,Ce,nn=`Configuration objects inherit from <a href="/docs/transformers/main/en/main_classes/configuration#transformers.PretrainedConfig">PretrainedConfig</a> and can be used to control the model outputs. Read the
documentation from <a href="/docs/transformers/main/en/main_classes/configuration#transformers.PretrainedConfig">PretrainedConfig</a> for more information.`,lt,pe,ct,T,ue,Mt,ze,on=`The bare Zamba Model outputting raw hidden-states without any specific head on top.
This model inherits from <a href="/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel">PreTrainedModel</a>. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
etc.)`,$t,Ze,an=`This model is also a PyTorch <a href="https://pytorch.org/docs/stable/nn.html#torch.nn.Module" rel="nofollow">torch.nn.Module</a> subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`,wt,xe,sn="Transformer decoder consisting of <em>config.num_hidden_layers</em> layers. Each layer is a <code>ZambaDecoderLayer</code>",Ct,I,he,zt,Le,rn='The <a href="/docs/transformers/main/en/model_doc/zamba#transformers.ZambaModel">ZambaModel</a> forward method, overrides the <code>__call__</code> special method.',Zt,U,mt,fe,pt,j,ge,xt,z,_e,Lt,qe,dn='The <a href="/docs/transformers/main/en/model_doc/zamba#transformers.ZambaForCausalLM">ZambaForCausalLM</a> forward method, overrides the <code>__call__</code> special method.',qt,A,Ft,N,ut,be,ht,y,ye,It,Fe,ln="The Zamba Model with a sequence classification head on top (linear layer).",Ht,Ie,cn=`<a href="/docs/transformers/main/en/model_doc/zamba#transformers.ZambaForSequenceClassification">ZambaForSequenceClassification</a> uses the last token in order to do the classification, as other causal models
(e.g. GPT-2) do.`,jt,He,mn=`Since it does classification on the last token, it requires to know the position of the last token. If a
<code>pad_token_id</code> is defined in the configuration, it finds the last token that is not a padding token in each row. If
no <code>pad_token_id</code> is defined, it simply takes the last value in each row of the batch. Since it cannot guess the
padding tokens when <code>inputs_embeds</code> are passed instead of <code>input_ids</code>, it does the same (take the last value in
each row of the batch).`,Pt,je,pn=`This model inherits from <a href="/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel">PreTrainedModel</a>. Check the superclass documentation for the generic methods the
library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
etc.)`,Wt,Pe,un=`This model is also a PyTorch <a href="https://pytorch.org/docs/stable/nn.html#torch.nn.Module" rel="nofollow">torch.nn.Module</a> subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`,Bt,H,ve,Ut,We,hn='The <a href="/docs/transformers/main/en/model_doc/zamba#transformers.ZambaForSequenceClassification">ZambaForSequenceClassification</a> forward method, overrides the <code>__call__</code> special method.',At,S,ft,ke,gt,Ue,_t;return C=new x({props:{title:"Zamba",local:"zamba",headingTag:"h1"}}),O=new x({props:{title:"Model details",local:"model-details",headingTag:"h2"}}),E=new x({props:{title:"Quick start",local:"quick-start",headingTag:"h2"}}),R=new x({props:{title:"Presequities",local:"presequities",headingTag:"h3"}}),V=new bt({props:{code:"cGlwJTIwaW5zdGFsbCUyMHRyYW5zZm9ybWVycyUzRSUzRDQuNDUuMA==",highlighted:"pip install transformers&gt;=4.45.0",wrap:!1}}),Q=new bt({props:{code:"cGlwJTIwaW5zdGFsbCUyMG1hbWJhLXNzbSUyMGNhdXNhbC1jb252MWQlM0UlM0QxLjIuMA==",highlighted:"pip install mamba-ssm causal-conv1d&gt;=1.2.0",wrap:!1}}),te=new x({props:{title:"Inference",local:"inference",headingTag:"h2"}}),ne=new bt({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Ub2tlbml6ZXIlMkMlMjBBdXRvTW9kZWxGb3JDYXVzYWxMTSUwQWltcG9ydCUyMHRvcmNoJTBBJTBBdG9rZW5pemVyJTIwJTNEJTIwQXV0b1Rva2VuaXplci5mcm9tX3ByZXRyYWluZWQoJTIyWnlwaHJhJTJGWmFtYmEtN0ItdjElMjIpJTBBbW9kZWwlMjAlM0QlMjBBdXRvTW9kZWxGb3JDYXVzYWxMTS5mcm9tX3ByZXRyYWluZWQoJTIyWnlwaHJhJTJGWmFtYmEtN0ItdjElMjIlMkMlMjBkZXZpY2VfbWFwJTNEJTIyYXV0byUyMiUyQyUyMHRvcmNoX2R0eXBlJTNEdG9yY2guYmZsb2F0MTYpJTBBJTBBaW5wdXRfdGV4dCUyMCUzRCUyMCUyMkElMjBmdW5ueSUyMHByb21wdCUyMHdvdWxkJTIwYmUlMjAlMjIlMEFpbnB1dF9pZHMlMjAlM0QlMjB0b2tlbml6ZXIoaW5wdXRfdGV4dCUyQyUyMHJldHVybl90ZW5zb3JzJTNEJTIycHQlMjIpLnRvKCUyMmN1ZGElMjIpJTBBJTBBb3V0cHV0cyUyMCUzRCUyMG1vZGVsLmdlbmVyYXRlKCoqaW5wdXRfaWRzJTJDJTIwbWF4X25ld190b2tlbnMlM0QxMDApJTBBcHJpbnQodG9rZW5pemVyLmRlY29kZShvdXRwdXRzJTVCMCU1RCkp",highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, AutoModelForCausalLM
<span class="hljs-keyword">import</span> torch

tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;Zyphra/Zamba-7B-v1&quot;</span>)
model = AutoModelForCausalLM.from_pretrained(<span class="hljs-string">&quot;Zyphra/Zamba-7B-v1&quot;</span>, device_map=<span class="hljs-string">&quot;auto&quot;</span>, torch_dtype=torch.bfloat16)

input_text = <span class="hljs-string">&quot;A funny prompt would be &quot;</span>
input_ids = tokenizer(input_text, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>).to(<span class="hljs-string">&quot;cuda&quot;</span>)

outputs = model.generate(**input_ids, max_new_tokens=<span class="hljs-number">100</span>)
<span class="hljs-built_in">print</span>(tokenizer.decode(outputs[<span class="hljs-number">0</span>]))`,wrap:!1}}),oe=new x({props:{title:"Model card",local:"model-card",headingTag:"h2"}}),re=new x({props:{title:"Issues",local:"issues",headingTag:"h2"}}),de=new x({props:{title:"License",local:"license",headingTag:"h2"}}),ce=new x({props:{title:"ZambaConfig",local:"transformers.ZambaConfig",headingTag:"h2"}}),me=new Me({props:{name:"class transformers.ZambaConfig",anchor:"transformers.ZambaConfig",parameters:[{name:"vocab_size",val:" = 32000"},{name:"tie_word_embeddings",val:" = True"},{name:"hidden_size",val:" = 3712"},{name:"attention_hidden_size",val:" = None"},{name:"intermediate_size",val:" = 14848"},{name:"num_hidden_layers",val:" = 76"},{name:"num_attention_heads",val:" = 16"},{name:"attention_head_dim",val:" = None"},{name:"num_key_value_heads",val:" = 16"},{name:"n_mamba_heads",val:" = 2"},{name:"hidden_act",val:" = 'gelu'"},{name:"hidden_mamba_act",val:" = 'silu'"},{name:"initializer_range",val:" = 0.02"},{name:"rms_norm_eps",val:" = 1e-05"},{name:"use_cache",val:" = True"},{name:"num_logits_to_keep",val:" = 1"},{name:"pad_token_id",val:" = 0"},{name:"bos_token_id",val:" = 1"},{name:"eos_token_id",val:" = 2"},{name:"max_position_embeddings",val:" = 4096"},{name:"attention_dropout",val:" = 0.0"},{name:"attn_layer_period",val:" = 6"},{name:"attn_layer_offset",val:" = 4"},{name:"use_mamba_kernels",val:" = True"},{name:"mamba_d_state",val:" = 16"},{name:"mamba_d_conv",val:" = 4"},{name:"mamba_expand",val:" = 2"},{name:"mamba_dt_rank",val:" = 'auto'"},{name:"time_step_min",val:" = 0.001"},{name:"time_step_max",val:" = 0.1"},{name:"time_step_floor",val:" = 0.0001"},{name:"mamba_conv_bias",val:" = True"},{name:"mamba_proj_bias",val:" = False"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.ZambaConfig.vocab_size",description:`<strong>vocab_size</strong> (<code>int</code>, <em>optional</em>, defaults to 32000) &#x2014;
Vocabulary size of the Zamba model. Defines the number of different tokens that can be represented by the
<code>inputs_ids</code> passed when calling <a href="/docs/transformers/main/en/model_doc/zamba#transformers.ZambaModel">ZambaModel</a>`,name:"vocab_size"},{anchor:"transformers.ZambaConfig.tie_word_embeddings",description:`<strong>tie_word_embeddings</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether the model&#x2019;s input and output word embeddings should be tied. Note that this is only relevant if the
model has a output word embedding layer.`,name:"tie_word_embeddings"},{anchor:"transformers.ZambaConfig.hidden_size",description:`<strong>hidden_size</strong> (<code>int</code>, <em>optional</em>, defaults to 3712) &#x2014;
Dimension of the hidden representations.`,name:"hidden_size"},{anchor:"transformers.ZambaConfig.attention_hidden_size",description:`<strong>attention_hidden_size</strong> (<code>int</code>, <em>optional</em>) &#x2014;
Dimension of the hidden representations of the inputs to the Attention layer.`,name:"attention_hidden_size"},{anchor:"transformers.ZambaConfig.intermediate_size",description:`<strong>intermediate_size</strong> (<code>int</code>, <em>optional</em>, defaults to 14848) &#x2014;
Dimension of the MLP representations.`,name:"intermediate_size"},{anchor:"transformers.ZambaConfig.num_hidden_layers",description:`<strong>num_hidden_layers</strong> (<code>int</code>, <em>optional</em>, defaults to 76) &#x2014;
Number of hidden layers in the model.`,name:"num_hidden_layers"},{anchor:"transformers.ZambaConfig.num_attention_heads",description:`<strong>num_attention_heads</strong> (<code>int</code>, <em>optional</em>, defaults to 16) &#x2014;
Number of attention heads for each attention layer in the Transformer decoder.`,name:"num_attention_heads"},{anchor:"transformers.ZambaConfig.attention_head_dim",description:`<strong>attention_head_dim</strong> (<code>int</code>, <em>optional</em>) &#x2014;
Dimension of the attention head in the Transformer decoder.`,name:"attention_head_dim"},{anchor:"transformers.ZambaConfig.num_key_value_heads",description:`<strong>num_key_value_heads</strong> (<code>int</code>, <em>optional</em>, defaults to 16) &#x2014;
This is the number of key_value heads that should be used to implement Grouped Query Attention. If
<code>num_key_value_heads=None</code>, the model will use Multi Head Attention (MHA), if
\`num_key_value_heads=1 the model will use Multi Query Attention (MQA) otherwise GQA is used. When
converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed
by meanpooling all the original heads within that group. For more details checkout <a href="https://arxiv.org/pdf/2305.13245.pdf" rel="nofollow">this
paper</a>.`,name:"num_key_value_heads"},{anchor:"transformers.ZambaConfig.n_mamba_heads",description:`<strong>n_mamba_heads</strong> (<code>int</code>, <em>optional</em>, defaults to 2) &#x2014;
Number of mamba heads for each mamba layer.`,name:"n_mamba_heads"},{anchor:"transformers.ZambaConfig.hidden_act",description:`<strong>hidden_act</strong> (<code>str</code> or <code>function</code>, <em>optional</em>, defaults to <code>&quot;gelu&quot;</code>) &#x2014;
The non-linear activation function (function or string) in the decoder.`,name:"hidden_act"},{anchor:"transformers.ZambaConfig.hidden_mamba_act",description:`<strong>hidden_mamba_act</strong> (<code>str</code> or <code>function</code>, <em>optional</em>, defaults to <code>&quot;silu&quot;</code>) &#x2014;
The non-linear activation function (function or string) in the mamba layer.`,name:"hidden_mamba_act"},{anchor:"transformers.ZambaConfig.initializer_range",description:`<strong>initializer_range</strong> (<code>float</code>, <em>optional</em>, defaults to 0.02) &#x2014;
The standard deviation of the truncated_normal_initializer for initializing all weight matrices.`,name:"initializer_range"},{anchor:"transformers.ZambaConfig.rms_norm_eps",description:`<strong>rms_norm_eps</strong> (<code>float</code>, <em>optional</em>, defaults to 1e-05) &#x2014;
The epsilon used by the rms normalization layers.`,name:"rms_norm_eps"},{anchor:"transformers.ZambaConfig.use_cache",description:`<strong>use_cache</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Whether or not the model should return the last key/values attentions (not used by all models). Only
relevant if <code>config.is_decoder=True</code>.`,name:"use_cache"},{anchor:"transformers.ZambaConfig.num_logits_to_keep",description:`<strong>num_logits_to_keep</strong> (<code>int</code> or <code>None</code>, <em>optional</em>, defaults to 1) &#x2014;
Number of prompt logits to calculate during generation. If <code>None</code>, all logits will be calculated. If an
integer value, only last <code>num_logits_to_keep</code> logits will be calculated. Default is 1 because only the
logits of the last prompt token are needed for generation. For long sequences, the logits for the entire
sequence may use a lot of memory so, setting <code>num_logits_to_keep=1</code> will reduce memory footprint
significantly.`,name:"num_logits_to_keep"},{anchor:"transformers.ZambaConfig.pad_token_id",description:`<strong>pad_token_id</strong> (<code>int</code>, <em>optional</em>, defaults to 0) &#x2014;
The id of the padding token.`,name:"pad_token_id"},{anchor:"transformers.ZambaConfig.bos_token_id",description:`<strong>bos_token_id</strong> (<code>int</code>, <em>optional</em>, defaults to 1) &#x2014;
The id of the &#x201C;beginning-of-sequence&#x201D; token.`,name:"bos_token_id"},{anchor:"transformers.ZambaConfig.eos_token_id",description:`<strong>eos_token_id</strong> (<code>int</code>, <em>optional</em>, defaults to 2) &#x2014;
The id of the &#x201C;end-of-sequence&#x201D; token.`,name:"eos_token_id"},{anchor:"transformers.ZambaConfig.max_position_embeddings",description:`<strong>max_position_embeddings</strong> (<code>int</code>, <em>optional</em>, defaults to 4096) &#x2014;
This value doesn&#x2019;t have any real effect. The maximum sequence length that this model is intended to be
used with. It can be used with longer sequences, but performance may degrade.`,name:"max_position_embeddings"},{anchor:"transformers.ZambaConfig.attention_dropout",description:`<strong>attention_dropout</strong> (<code>float</code>, <em>optional</em>, defaults to 0.0) &#x2014;
The dropout ratio for the attention probabilities.`,name:"attention_dropout"},{anchor:"transformers.ZambaConfig.attn_layer_period",description:`<strong>attn_layer_period</strong> (<code>int</code>, <em>optional</em>, defaults to 6) &#x2014;
Once in this many layers, we will have a shared attention layer`,name:"attn_layer_period"},{anchor:"transformers.ZambaConfig.attn_layer_offset",description:`<strong>attn_layer_offset</strong> (<code>int</code>, <em>optional</em>, defaults to 4) &#x2014;
Offset of the shared attention layer`,name:"attn_layer_offset"},{anchor:"transformers.ZambaConfig.use_mamba_kernels",description:`<strong>use_mamba_kernels</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Flag indicating whether or not to use the fast mamba kernels. These are available only if <code>mamba-ssm</code> and
<code>causal-conv1d</code> are installed, and the mamba modules are running on a CUDA device. Raises ValueError if
<code>True</code> and kernels are not available`,name:"use_mamba_kernels"},{anchor:"transformers.ZambaConfig.mamba_d_state",description:`<strong>mamba_d_state</strong> (<code>int</code>, <em>optional</em>, defaults to 16) &#x2014;
The dimension the mamba state space latents`,name:"mamba_d_state"},{anchor:"transformers.ZambaConfig.mamba_d_conv",description:`<strong>mamba_d_conv</strong> (<code>int</code>, <em>optional</em>, defaults to 4) &#x2014;
The size of the mamba convolution kernel`,name:"mamba_d_conv"},{anchor:"transformers.ZambaConfig.mamba_expand",description:`<strong>mamba_expand</strong> (<code>int</code>, <em>optional</em>, defaults to 2) &#x2014;
Expanding factor (relative to hidden_size) used to determine the mamba intermediate size`,name:"mamba_expand"},{anchor:"transformers.ZambaConfig.mamba_dt_rank",description:`<strong>mamba_dt_rank</strong> (<code>Union[int,str]</code>, <em>optional</em>, defaults to <code>&quot;auto&quot;</code>) &#x2014;
Rank of the mamba discretization projection matrix. <code>&quot;auto&quot;</code> means that it will default to <code>math.ceil(self.hidden_size / 16)</code>`,name:"mamba_dt_rank"},{anchor:"transformers.ZambaConfig.time_step_min",description:`<strong>time_step_min</strong> (<code>float</code>, <em>optional</em>, defaults to 0.001) &#x2014;
Minimum <code>time_step</code> used to bound <code>dt_proj_bias</code>.`,name:"time_step_min"},{anchor:"transformers.ZambaConfig.time_step_max",description:`<strong>time_step_max</strong> (<code>float</code>, <em>optional</em>, defaults to 0.1) &#x2014;
Maximum <code>time_step</code> used to bound <code>dt_proj_bias</code>.`,name:"time_step_max"},{anchor:"transformers.ZambaConfig.time_step_floor",description:`<strong>time_step_floor</strong> (<code>float</code>, <em>optional</em>, defaults to 0.0001) &#x2014;
Minimum clamping value of the <code>dt_proj.bias</code> layer initialization.`,name:"time_step_floor"},{anchor:"transformers.ZambaConfig.mamba_conv_bias",description:`<strong>mamba_conv_bias</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>True</code>) &#x2014;
Flag indicating whether or not to use bias in the convolution layer of the mamba mixer block.`,name:"mamba_conv_bias"},{anchor:"transformers.ZambaConfig.mamba_proj_bias",description:`<strong>mamba_proj_bias</strong> (<code>bool</code>, <em>optional</em>, defaults to <code>False</code>) &#x2014;
Flag indicating whether or not to use bias in the input and output projections ([&#x201C;in_proj&#x201D;, &#x201C;out_proj&#x201D;]) of the mamba mixer block`,name:"mamba_proj_bias"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/zamba/configuration_zamba.py#L26"}}),pe=new x({props:{title:"ZambaModel",local:"transformers.ZambaModel",headingTag:"h2"}}),ue=new Me({props:{name:"class transformers.ZambaModel",anchor:"transformers.ZambaModel",parameters:[{name:"config",val:": ZambaConfig"}],parametersDescription:[{anchor:"transformers.ZambaModel.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/zamba#transformers.ZambaConfig">ZambaConfig</a>) &#x2014;
Model configuration class with all the parameters of the model. Initializing with a config file does not
load the weights associated with the model, only the configuration. Check out the
<a href="/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"},{anchor:"transformers.ZambaModel.config",description:"<strong>config</strong> &#x2014; ZambaConfig",name:"config"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/zamba/modeling_zamba.py#L1157"}}),he=new Me({props:{name:"forward",anchor:"transformers.ZambaModel.forward",parameters:[{name:"input_ids",val:": LongTensor = None"},{name:"attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"position_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"past_key_values",val:": typing.Optional[transformers.models.zamba.modeling_zamba.HybridMambaAttentionDynamicCache] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.FloatTensor] = None"},{name:"use_cache",val:": typing.Optional[bool] = None"},{name:"output_attentions",val:": typing.Optional[bool] = None"},{name:"output_hidden_states",val:": typing.Optional[bool] = None"},{name:"return_dict",val:": typing.Optional[bool] = None"},{name:"cache_position",val:": typing.Optional[torch.LongTensor] = None"}],parametersDescription:[{anchor:"transformers.ZambaModel.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide
it.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.ZambaModel.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Mask to avoid performing attention on padding token indices. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 for tokens that are <strong>not masked</strong>,</li>
<li>0 for tokens that are <strong>masked</strong>.</li>
</ul>
<p><a href="../glossary#attention-mask">What are attention masks?</a></p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p>If <code>past_key_values</code> is used, optionally only the last <code>input_ids</code> have to be input (see
<code>past_key_values</code>).</p>
<p>If you want to change padding behavior, you should read <code>modeling_opt._prepare_decoder_attention_mask</code>
and modify to your needs. See diagram 1 in <a href="https://arxiv.org/abs/1910.13461" rel="nofollow">the paper</a> for more
information on the default strategy.</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"attention_mask"},{anchor:"transformers.ZambaModel.forward.position_ids",description:`<strong>position_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.n_positions - 1]</code>.</p>
<p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.ZambaModel.forward.past_key_values",description:`<strong>past_key_values</strong> (<code>HybridMambaAttentionDynamicCache</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
A HybridMambaAttentionDynamicCache object containing pre-computed hidden-states (keys and values in the
self-attention blocks and convolution and ssm states in the mamba blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.
Key and value cache tensors have shape <code>(batch_size, num_heads, seq_len, head_dim)</code>.
Convolution and ssm states tensors have shape <code>(batch_size, d_inner, d_conv)</code> and
<code>(batch_size, d_inner, d_state)</code> respectively.
See the <code>HybridMambaAttentionDynamicCache</code> class for more details.</p>
<p>If <code>past_key_values</code> are used, the user can optionally input only the last <code>input_ids</code> (those that
don&#x2019;t have their past key value states given to this model) of shape <code>(batch_size, 1)</code> instead of all
<code>input_ids</code> of shape <code>(batch_size, sequence_length)</code>.`,name:"past_key_values"},{anchor:"transformers.ZambaModel.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Optionally, instead of passing <code>input_ids</code> you can choose to directly pass an embedded representation. This
is useful if you want more control over how to convert <code>input_ids</code> indices into associated vectors than the
model&#x2019;s internal embedding lookup matrix.`,name:"inputs_embeds"},{anchor:"transformers.ZambaModel.forward.use_cache",description:`<strong>use_cache</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
If set to <code>True</code>, <code>past_key_values</code> key value states are returned and can be used to speed up decoding (see
<code>past_key_values</code>).`,name:"use_cache"},{anchor:"transformers.ZambaModel.forward.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the attentions tensors of all attention layers. See <code>attentions</code> under returned
tensors for more detail.`,name:"output_attentions"},{anchor:"transformers.ZambaModel.forward.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the hidden states of all layers. See <code>hidden_states</code> under returned tensors for
more detail.`,name:"output_hidden_states"},{anchor:"transformers.ZambaModel.forward.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return a <a href="/docs/transformers/main/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"},{anchor:"transformers.ZambaModel.forward.cache_position",description:`<strong>cache_position</strong> (<code>torch.LongTensor</code> of shape <code>(sequence_length)</code>, <em>optional</em>) &#x2014;
Indices depicting the position of the input sequence tokens in the sequence. Contrarily to <code>position_ids</code>,
this tensor is not affected by padding. It is used to update the cache in the correct position and to infer
the complete sequence length.`,name:"cache_position"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/zamba/modeling_zamba.py#L1222"}}),U=new Nt({props:{$$slots:{default:[Mn]},$$scope:{ctx:F}}}),fe=new x({props:{title:"ZambaForCausalLM",local:"transformers.ZambaForCausalLM",headingTag:"h2"}}),ge=new Me({props:{name:"class transformers.ZambaForCausalLM",anchor:"transformers.ZambaForCausalLM",parameters:[{name:"config",val:": ZambaConfig"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/zamba/modeling_zamba.py#L1376"}}),_e=new Me({props:{name:"forward",anchor:"transformers.ZambaForCausalLM.forward",parameters:[{name:"input_ids",val:": LongTensor = None"},{name:"attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"position_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"past_key_values",val:": typing.Optional[transformers.models.zamba.modeling_zamba.HybridMambaAttentionDynamicCache] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.FloatTensor] = None"},{name:"labels",val:": typing.Optional[torch.LongTensor] = None"},{name:"use_cache",val:": typing.Optional[bool] = None"},{name:"output_attentions",val:": typing.Optional[bool] = None"},{name:"output_hidden_states",val:": typing.Optional[bool] = None"},{name:"return_dict",val:": typing.Optional[bool] = None"},{name:"cache_position",val:": typing.Optional[torch.LongTensor] = None"},{name:"num_logits_to_keep",val:": int = 0"},{name:"**loss_kwargs",val:""}],parametersDescription:[{anchor:"transformers.ZambaForCausalLM.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide
it.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.ZambaForCausalLM.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Mask to avoid performing attention on padding token indices. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 for tokens that are <strong>not masked</strong>,</li>
<li>0 for tokens that are <strong>masked</strong>.</li>
</ul>
<p><a href="../glossary#attention-mask">What are attention masks?</a></p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p>If <code>past_key_values</code> is used, optionally only the last <code>input_ids</code> have to be input (see
<code>past_key_values</code>).</p>
<p>If you want to change padding behavior, you should read <code>modeling_opt._prepare_decoder_attention_mask</code>
and modify to your needs. See diagram 1 in <a href="https://arxiv.org/abs/1910.13461" rel="nofollow">the paper</a> for more
information on the default strategy.</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"attention_mask"},{anchor:"transformers.ZambaForCausalLM.forward.position_ids",description:`<strong>position_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.n_positions - 1]</code>.</p>
<p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.ZambaForCausalLM.forward.past_key_values",description:`<strong>past_key_values</strong> (<code>HybridMambaAttentionDynamicCache</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
A HybridMambaAttentionDynamicCache object containing pre-computed hidden-states (keys and values in the
self-attention blocks and convolution and ssm states in the mamba blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.
Key and value cache tensors have shape <code>(batch_size, num_heads, seq_len, head_dim)</code>.
Convolution and ssm states tensors have shape <code>(batch_size, d_inner, d_conv)</code> and
<code>(batch_size, d_inner, d_state)</code> respectively.
See the <code>HybridMambaAttentionDynamicCache</code> class for more details.</p>
<p>If <code>past_key_values</code> are used, the user can optionally input only the last <code>input_ids</code> (those that
don&#x2019;t have their past key value states given to this model) of shape <code>(batch_size, 1)</code> instead of all
<code>input_ids</code> of shape <code>(batch_size, sequence_length)</code>.`,name:"past_key_values"},{anchor:"transformers.ZambaForCausalLM.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Optionally, instead of passing <code>input_ids</code> you can choose to directly pass an embedded representation. This
is useful if you want more control over how to convert <code>input_ids</code> indices into associated vectors than the
model&#x2019;s internal embedding lookup matrix.`,name:"inputs_embeds"},{anchor:"transformers.ZambaForCausalLM.forward.use_cache",description:`<strong>use_cache</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
If set to <code>True</code>, <code>past_key_values</code> key value states are returned and can be used to speed up decoding (see
<code>past_key_values</code>).`,name:"use_cache"},{anchor:"transformers.ZambaForCausalLM.forward.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the attentions tensors of all attention layers. See <code>attentions</code> under returned
tensors for more detail.`,name:"output_attentions"},{anchor:"transformers.ZambaForCausalLM.forward.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the hidden states of all layers. See <code>hidden_states</code> under returned tensors for
more detail.`,name:"output_hidden_states"},{anchor:"transformers.ZambaForCausalLM.forward.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return a <a href="/docs/transformers/main/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"},{anchor:"transformers.ZambaForCausalLM.forward.cache_position",description:`<strong>cache_position</strong> (<code>torch.LongTensor</code> of shape <code>(sequence_length)</code>, <em>optional</em>) &#x2014;
Indices depicting the position of the input sequence tokens in the sequence. Contrarily to <code>position_ids</code>,
this tensor is not affected by padding. It is used to update the cache in the correct position and to infer
the complete sequence length.`,name:"cache_position"},{anchor:"transformers.ZambaForCausalLM.forward.Args",description:`<strong>Args</strong> &#x2014;
labels (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>):
Labels for computing the masked language modeling loss. Indices should either be in <code>[0, ..., config.vocab_size]</code> or -100 (see <code>input_ids</code> docstring). Tokens with indices set to <code>-100</code> are ignored
(masked), the loss is only computed for the tokens with labels in <code>[0, ..., config.vocab_size]</code>.</p>
<p>num_logits_to_keep (<code>int</code> or <code>None</code>, <em>optional</em>):
Calculate logits for the last <code>num_logits_to_keep</code> tokens. If <code>None</code>, calculate logits for all
<code>input_ids</code>. Only last token logits are needed for generation, and calculating them only for that token
can save memory, which becomes pretty significant for long sequences.`,name:"Args"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/zamba/modeling_zamba.py#L1405",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>A <a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast"
>transformers.modeling_outputs.CausalLMOutputWithPast</a> or a tuple of
<code>torch.FloatTensor</code> (if <code>return_dict=False</code> is passed or when <code>config.return_dict=False</code>) comprising various
elements depending on the configuration (<a
  href="/docs/transformers/main/en/model_doc/zamba#transformers.ZambaConfig"
>ZambaConfig</a>) and inputs.</p>
<ul>
<li>
<p><strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) — Language modeling loss (for next-token prediction).</p>
</li>
<li>
<p><strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) — Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).</p>
</li>
<li>
<p><strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) — Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>)</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.</p>
</li>
<li>
<p><strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) — Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.</p>
</li>
<li>
<p><strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) — Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.</p>
</li>
</ul>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><a
  href="/docs/transformers/main/en/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast"
>transformers.modeling_outputs.CausalLMOutputWithPast</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),A=new Nt({props:{$$slots:{default:[$n]},$$scope:{ctx:F}}}),N=new kn({props:{anchor:"transformers.ZambaForCausalLM.forward.example",$$slots:{default:[wn]},$$scope:{ctx:F}}}),be=new x({props:{title:"ZambaForSequenceClassification",local:"transformers.ZambaForSequenceClassification",headingTag:"h2"}}),ye=new Me({props:{name:"class transformers.ZambaForSequenceClassification",anchor:"transformers.ZambaForSequenceClassification",parameters:[{name:"config",val:""}],parametersDescription:[{anchor:"transformers.ZambaForSequenceClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/main/en/model_doc/zamba#transformers.ZambaConfig">ZambaConfig</a>) &#x2014;
Model configuration class with all the parameters of the model. Initializing with a config file does not
load the weights associated with the model, only the configuration. Check out the
<a href="/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/zamba/modeling_zamba.py#L1550"}}),ve=new Me({props:{name:"forward",anchor:"transformers.ZambaForSequenceClassification.forward",parameters:[{name:"input_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"attention_mask",val:": typing.Optional[torch.Tensor] = None"},{name:"position_ids",val:": typing.Optional[torch.LongTensor] = None"},{name:"past_key_values",val:": typing.Union[transformers.cache_utils.Cache, typing.List[torch.FloatTensor], NoneType] = None"},{name:"inputs_embeds",val:": typing.Optional[torch.FloatTensor] = None"},{name:"labels",val:": typing.Optional[torch.LongTensor] = None"},{name:"use_cache",val:": typing.Optional[bool] = None"},{name:"output_attentions",val:": typing.Optional[bool] = None"},{name:"output_hidden_states",val:": typing.Optional[bool] = None"},{name:"return_dict",val:": typing.Optional[bool] = None"}],parametersDescription:[{anchor:"transformers.ZambaForSequenceClassification.forward.input_ids",description:`<strong>input_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide
it.</p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p><a href="../glossary#input-ids">What are input IDs?</a>`,name:"input_ids"},{anchor:"transformers.ZambaForSequenceClassification.forward.attention_mask",description:`<strong>attention_mask</strong> (<code>torch.Tensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Mask to avoid performing attention on padding token indices. Mask values selected in <code>[0, 1]</code>:</p>
<ul>
<li>1 for tokens that are <strong>not masked</strong>,</li>
<li>0 for tokens that are <strong>masked</strong>.</li>
</ul>
<p><a href="../glossary#attention-mask">What are attention masks?</a></p>
<p>Indices can be obtained using <a href="/docs/transformers/main/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p>If <code>past_key_values</code> is used, optionally only the last <code>input_ids</code> have to be input (see
<code>past_key_values</code>).</p>
<p>If you want to change padding behavior, you should read <code>modeling_opt._prepare_decoder_attention_mask</code>
and modify to your needs. See diagram 1 in <a href="https://arxiv.org/abs/1910.13461" rel="nofollow">the paper</a> for more
information on the default strategy.</p>
<ul>
<li>1 indicates the head is <strong>not masked</strong>,</li>
<li>0 indicates the head is <strong>masked</strong>.</li>
</ul>`,name:"attention_mask"},{anchor:"transformers.ZambaForSequenceClassification.forward.position_ids",description:`<strong>position_ids</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size, sequence_length)</code>, <em>optional</em>) &#x2014;
Indices of positions of each input sequence tokens in the position embeddings. Selected in the range <code>[0, config.n_positions - 1]</code>.</p>
<p><a href="../glossary#position-ids">What are position IDs?</a>`,name:"position_ids"},{anchor:"transformers.ZambaForSequenceClassification.forward.past_key_values",description:`<strong>past_key_values</strong> (<code>HybridMambaAttentionDynamicCache</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
A HybridMambaAttentionDynamicCache object containing pre-computed hidden-states (keys and values in the
self-attention blocks and convolution and ssm states in the mamba blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.
Key and value cache tensors have shape <code>(batch_size, num_heads, seq_len, head_dim)</code>.
Convolution and ssm states tensors have shape <code>(batch_size, d_inner, d_conv)</code> and
<code>(batch_size, d_inner, d_state)</code> respectively.
See the <code>HybridMambaAttentionDynamicCache</code> class for more details.</p>
<p>If <code>past_key_values</code> are used, the user can optionally input only the last <code>input_ids</code> (those that
don&#x2019;t have their past key value states given to this model) of shape <code>(batch_size, 1)</code> instead of all
<code>input_ids</code> of shape <code>(batch_size, sequence_length)</code>.`,name:"past_key_values"},{anchor:"transformers.ZambaForSequenceClassification.forward.inputs_embeds",description:`<strong>inputs_embeds</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Optionally, instead of passing <code>input_ids</code> you can choose to directly pass an embedded representation. This
is useful if you want more control over how to convert <code>input_ids</code> indices into associated vectors than the
model&#x2019;s internal embedding lookup matrix.`,name:"inputs_embeds"},{anchor:"transformers.ZambaForSequenceClassification.forward.use_cache",description:`<strong>use_cache</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
If set to <code>True</code>, <code>past_key_values</code> key value states are returned and can be used to speed up decoding (see
<code>past_key_values</code>).`,name:"use_cache"},{anchor:"transformers.ZambaForSequenceClassification.forward.output_attentions",description:`<strong>output_attentions</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the attentions tensors of all attention layers. See <code>attentions</code> under returned
tensors for more detail.`,name:"output_attentions"},{anchor:"transformers.ZambaForSequenceClassification.forward.output_hidden_states",description:`<strong>output_hidden_states</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return the hidden states of all layers. See <code>hidden_states</code> under returned tensors for
more detail.`,name:"output_hidden_states"},{anchor:"transformers.ZambaForSequenceClassification.forward.return_dict",description:`<strong>return_dict</strong> (<code>bool</code>, <em>optional</em>) &#x2014;
Whether or not to return a <a href="/docs/transformers/main/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"},{anchor:"transformers.ZambaForSequenceClassification.forward.cache_position",description:`<strong>cache_position</strong> (<code>torch.LongTensor</code> of shape <code>(sequence_length)</code>, <em>optional</em>) &#x2014;
Indices depicting the position of the input sequence tokens in the sequence. Contrarily to <code>position_ids</code>,
this tensor is not affected by padding. It is used to update the cache in the correct position and to infer
the complete sequence length.`,name:"cache_position"},{anchor:"transformers.ZambaForSequenceClassification.forward.labels",description:`<strong>labels</strong> (<code>torch.LongTensor</code> of shape <code>(batch_size,)</code>, <em>optional</em>) &#x2014;
Labels for computing the sequence classification/regression loss. Indices should be in <code>[0, ..., config.num_labels - 1]</code>. If <code>config.num_labels == 1</code> a regression loss is computed (Mean-Square loss), If
<code>config.num_labels &gt; 1</code> a classification loss is computed (Cross-Entropy).`,name:"labels"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/models/zamba/modeling_zamba.py#L1582"}}),S=new Nt({props:{$$slots:{default:[Cn]},$$scope:{ctx:F}}}),ke=new Tn({props:{source:"https://github.com/huggingface/transformers/blob/main/docs/source/en/model_doc/zamba.md"}}),{c(){r=i("meta"),k=a(),m=i("p"),v=a(),p(C.$$.fragment),b=a(),L=i("p"),L.innerHTML=St,Ae=a(),D=i("p"),D.innerHTML=Jt,Ne=a(),p(O.$$.fragment),Se=a(),X=i("p"),X.innerHTML=Dt,Je=a(),B=i("img"),De=a(),p(E.$$.fragment),Oe=a(),p(R.$$.fragment),Xe=a(),G=i("p"),G.innerHTML=Xt,Ee=a(),p(V.$$.fragment),Re=a(),Y=i("p"),Y.innerHTML=Et,Ge=a(),p(Q.$$.fragment),Ve=a(),K=i("p"),K.textContent=Rt,Ye=a(),ee=i("p"),ee.innerHTML=Gt,Qe=a(),p(te.$$.fragment),Ke=a(),p(ne.$$.fragment),et=a(),p(oe.$$.fragment),tt=a(),ae=i("p"),ae.textContent=Vt,nt=a(),se=i("ul"),se.innerHTML=Yt,ot=a(),p(re.$$.fragment),at=a(),ie=i("p"),ie.innerHTML=Qt,st=a(),p(de.$$.fragment),rt=a(),le=i("p"),le.textContent=Kt,it=a(),p(ce.$$.fragment),dt=a(),$=i("div"),p(me.$$.fragment),vt=a(),$e=i("p"),$e.innerHTML=en,kt=a(),we=i("p"),we.innerHTML=tn,Tt=a(),Ce=i("p"),Ce.innerHTML=nn,lt=a(),p(pe.$$.fragment),ct=a(),T=i("div"),p(ue.$$.fragment),Mt=a(),ze=i("p"),ze.innerHTML=on,$t=a(),Ze=i("p"),Ze.innerHTML=an,wt=a(),xe=i("p"),xe.innerHTML=sn,Ct=a(),I=i("div"),p(he.$$.fragment),zt=a(),Le=i("p"),Le.innerHTML=rn,Zt=a(),p(U.$$.fragment),mt=a(),p(fe.$$.fragment),pt=a(),j=i("div"),p(ge.$$.fragment),xt=a(),z=i("div"),p(_e.$$.fragment),Lt=a(),qe=i("p"),qe.innerHTML=dn,qt=a(),p(A.$$.fragment),Ft=a(),p(N.$$.fragment),ut=a(),p(be.$$.fragment),ht=a(),y=i("div"),p(ye.$$.fragment),It=a(),Fe=i("p"),Fe.textContent=ln,Ht=a(),Ie=i("p"),Ie.innerHTML=cn,jt=a(),He=i("p"),He.innerHTML=mn,Pt=a(),je=i("p"),je.innerHTML=pn,Wt=a(),Pe=i("p"),Pe.innerHTML=un,Bt=a(),H=i("div"),p(ve.$$.fragment),Ut=a(),We=i("p"),We.innerHTML=hn,At=a(),p(S.$$.fragment),ft=a(),p(ke.$$.fragment),gt=a(),Ue=i("p"),this.h()},l(e){const t=vn("svelte-u9bgzb",document.head);r=d(t,"META",{name:!0,content:!0}),t.forEach(n),k=s(e),m=d(e,"P",{}),W(m).forEach(n),v=s(e),u(C.$$.fragment,e),b=s(e),L=d(e,"P",{"data-svelte-h":!0}),c(L)!=="svelte-1t92yrc"&&(L.innerHTML=St),Ae=s(e),D=d(e,"P",{"data-svelte-h":!0}),c(D)!=="svelte-1hxftw9"&&(D.innerHTML=Jt),Ne=s(e),u(O.$$.fragment,e),Se=s(e),X=d(e,"P",{"data-svelte-h":!0}),c(X)!=="svelte-1xvlxd9"&&(X.innerHTML=Dt),Je=s(e),B=d(e,"IMG",{src:!0,width:!0,height:!0}),De=s(e),u(E.$$.fragment,e),Oe=s(e),u(R.$$.fragment,e),Xe=s(e),G=d(e,"P",{"data-svelte-h":!0}),c(G)!=="svelte-xntbge"&&(G.innerHTML=Xt),Ee=s(e),u(V.$$.fragment,e),Re=s(e),Y=d(e,"P",{"data-svelte-h":!0}),c(Y)!=="svelte-1ruzjzk"&&(Y.innerHTML=Et),Ge=s(e),u(Q.$$.fragment,e),Ve=s(e),K=d(e,"P",{"data-svelte-h":!0}),c(K)!=="svelte-1kmjqje"&&(K.textContent=Rt),Ye=s(e),ee=d(e,"P",{"data-svelte-h":!0}),c(ee)!=="svelte-syhw7e"&&(ee.innerHTML=Gt),Qe=s(e),u(te.$$.fragment,e),Ke=s(e),u(ne.$$.fragment,e),et=s(e),u(oe.$$.fragment,e),tt=s(e),ae=d(e,"P",{"data-svelte-h":!0}),c(ae)!=="svelte-ktiv3r"&&(ae.textContent=Vt),nt=s(e),se=d(e,"UL",{"data-svelte-h":!0}),c(se)!=="svelte-mvai5e"&&(se.innerHTML=Yt),ot=s(e),u(re.$$.fragment,e),at=s(e),ie=d(e,"P",{"data-svelte-h":!0}),c(ie)!=="svelte-ry96i"&&(ie.innerHTML=Qt),st=s(e),u(de.$$.fragment,e),rt=s(e),le=d(e,"P",{"data-svelte-h":!0}),c(le)!=="svelte-9pg9vx"&&(le.textContent=Kt),it=s(e),u(ce.$$.fragment,e),dt=s(e),$=d(e,"DIV",{class:!0});var q=W($);u(me.$$.fragment,q),vt=s(q),$e=d(q,"P",{"data-svelte-h":!0}),c($e)!=="svelte-acog25"&&($e.innerHTML=en),kt=s(q),we=d(q,"P",{"data-svelte-h":!0}),c(we)!=="svelte-bbuukh"&&(we.innerHTML=tn),Tt=s(q),Ce=d(q,"P",{"data-svelte-h":!0}),c(Ce)!=="svelte-o55m63"&&(Ce.innerHTML=nn),q.forEach(n),lt=s(e),u(pe.$$.fragment,e),ct=s(e),T=d(e,"DIV",{class:!0});var w=W(T);u(ue.$$.fragment,w),Mt=s(w),ze=d(w,"P",{"data-svelte-h":!0}),c(ze)!=="svelte-yyb1sn"&&(ze.innerHTML=on),$t=s(w),Ze=d(w,"P",{"data-svelte-h":!0}),c(Ze)!=="svelte-hswkmf"&&(Ze.innerHTML=an),wt=s(w),xe=d(w,"P",{"data-svelte-h":!0}),c(xe)!=="svelte-18aqr7k"&&(xe.innerHTML=sn),Ct=s(w),I=d(w,"DIV",{class:!0});var P=W(I);u(he.$$.fragment,P),zt=s(P),Le=d(P,"P",{"data-svelte-h":!0}),c(Le)!=="svelte-d6y5u6"&&(Le.innerHTML=rn),Zt=s(P),u(U.$$.fragment,P),P.forEach(n),w.forEach(n),mt=s(e),u(fe.$$.fragment,e),pt=s(e),j=d(e,"DIV",{class:!0});var Te=W(j);u(ge.$$.fragment,Te),xt=s(Te),z=d(Te,"DIV",{class:!0});var J=W(z);u(_e.$$.fragment,J),Lt=s(J),qe=d(J,"P",{"data-svelte-h":!0}),c(qe)!=="svelte-qvmjhq"&&(qe.innerHTML=dn),qt=s(J),u(A.$$.fragment,J),Ft=s(J),u(N.$$.fragment,J),J.forEach(n),Te.forEach(n),ut=s(e),u(be.$$.fragment,e),ht=s(e),y=d(e,"DIV",{class:!0});var M=W(y);u(ye.$$.fragment,M),It=s(M),Fe=d(M,"P",{"data-svelte-h":!0}),c(Fe)!=="svelte-qc231a"&&(Fe.textContent=ln),Ht=s(M),Ie=d(M,"P",{"data-svelte-h":!0}),c(Ie)!=="svelte-1lnezad"&&(Ie.innerHTML=cn),jt=s(M),He=d(M,"P",{"data-svelte-h":!0}),c(He)!=="svelte-10ugs3m"&&(He.innerHTML=mn),Pt=s(M),je=d(M,"P",{"data-svelte-h":!0}),c(je)!=="svelte-6pahdo"&&(je.innerHTML=pn),Wt=s(M),Pe=d(M,"P",{"data-svelte-h":!0}),c(Pe)!=="svelte-hswkmf"&&(Pe.innerHTML=un),Bt=s(M),H=d(M,"DIV",{class:!0});var Be=W(H);u(ve.$$.fragment,Be),Ut=s(Be),We=d(Be,"P",{"data-svelte-h":!0}),c(We)!=="svelte-1xcang8"&&(We.innerHTML=hn),At=s(Be),u(S.$$.fragment,Be),Be.forEach(n),M.forEach(n),ft=s(e),u(ke.$$.fragment,e),gt=s(e),Ue=d(e,"P",{}),W(Ue).forEach(n),this.h()},h(){Z(r,"name","hf:doc:metadata"),Z(r,"content",Zn),gn(B.src,Ot="https://github.com/user-attachments/assets/c2cff209-b901-483c-87aa-774b82a0769f")||Z(B,"src",Ot),Z(B,"width","30%"),Z(B,"height","40%"),Z($,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),Z(I,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),Z(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(z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),Z(j,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),Z(H,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),Z(y,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8")},m(e,t){l(document.head,r),o(e,k,t),o(e,m,t),o(e,v,t),h(C,e,t),o(e,b,t),o(e,L,t),o(e,Ae,t),o(e,D,t),o(e,Ne,t),h(O,e,t),o(e,Se,t),o(e,X,t),o(e,Je,t),o(e,B,t),o(e,De,t),h(E,e,t),o(e,Oe,t),h(R,e,t),o(e,Xe,t),o(e,G,t),o(e,Ee,t),h(V,e,t),o(e,Re,t),o(e,Y,t),o(e,Ge,t),h(Q,e,t),o(e,Ve,t),o(e,K,t),o(e,Ye,t),o(e,ee,t),o(e,Qe,t),h(te,e,t),o(e,Ke,t),h(ne,e,t),o(e,et,t),h(oe,e,t),o(e,tt,t),o(e,ae,t),o(e,nt,t),o(e,se,t),o(e,ot,t),h(re,e,t),o(e,at,t),o(e,ie,t),o(e,st,t),h(de,e,t),o(e,rt,t),o(e,le,t),o(e,it,t),h(ce,e,t),o(e,dt,t),o(e,$,t),h(me,$,null),l($,vt),l($,$e),l($,kt),l($,we),l($,Tt),l($,Ce),o(e,lt,t),h(pe,e,t),o(e,ct,t),o(e,T,t),h(ue,T,null),l(T,Mt),l(T,ze),l(T,$t),l(T,Ze),l(T,wt),l(T,xe),l(T,Ct),l(T,I),h(he,I,null),l(I,zt),l(I,Le),l(I,Zt),h(U,I,null),o(e,mt,t),h(fe,e,t),o(e,pt,t),o(e,j,t),h(ge,j,null),l(j,xt),l(j,z),h(_e,z,null),l(z,Lt),l(z,qe),l(z,qt),h(A,z,null),l(z,Ft),h(N,z,null),o(e,ut,t),h(be,e,t),o(e,ht,t),o(e,y,t),h(ye,y,null),l(y,It),l(y,Fe),l(y,Ht),l(y,Ie),l(y,jt),l(y,He),l(y,Pt),l(y,je),l(y,Wt),l(y,Pe),l(y,Bt),l(y,H),h(ve,H,null),l(H,Ut),l(H,We),l(H,At),h(S,H,null),o(e,ft,t),h(ke,e,t),o(e,gt,t),o(e,Ue,t),_t=!0},p(e,[t]){const q={};t&2&&(q.$$scope={dirty:t,ctx:e}),U.$set(q);const w={};t&2&&(w.$$scope={dirty:t,ctx:e}),A.$set(w);const P={};t&2&&(P.$$scope={dirty:t,ctx:e}),N.$set(P);const Te={};t&2&&(Te.$$scope={dirty:t,ctx:e}),S.$set(Te)},i(e){_t||(f(C.$$.fragment,e),f(O.$$.fragment,e),f(E.$$.fragment,e),f(R.$$.fragment,e),f(V.$$.fragment,e),f(Q.$$.fragment,e),f(te.$$.fragment,e),f(ne.$$.fragment,e),f(oe.$$.fragment,e),f(re.$$.fragment,e),f(de.$$.fragment,e),f(ce.$$.fragment,e),f(me.$$.fragment,e),f(pe.$$.fragment,e),f(ue.$$.fragment,e),f(he.$$.fragment,e),f(U.$$.fragment,e),f(fe.$$.fragment,e),f(ge.$$.fragment,e),f(_e.$$.fragment,e),f(A.$$.fragment,e),f(N.$$.fragment,e),f(be.$$.fragment,e),f(ye.$$.fragment,e),f(ve.$$.fragment,e),f(S.$$.fragment,e),f(ke.$$.fragment,e),_t=!0)},o(e){g(C.$$.fragment,e),g(O.$$.fragment,e),g(E.$$.fragment,e),g(R.$$.fragment,e),g(V.$$.fragment,e),g(Q.$$.fragment,e),g(te.$$.fragment,e),g(ne.$$.fragment,e),g(oe.$$.fragment,e),g(re.$$.fragment,e),g(de.$$.fragment,e),g(ce.$$.fragment,e),g(me.$$.fragment,e),g(pe.$$.fragment,e),g(ue.$$.fragment,e),g(he.$$.fragment,e),g(U.$$.fragment,e),g(fe.$$.fragment,e),g(ge.$$.fragment,e),g(_e.$$.fragment,e),g(A.$$.fragment,e),g(N.$$.fragment,e),g(be.$$.fragment,e),g(ye.$$.fragment,e),g(ve.$$.fragment,e),g(S.$$.fragment,e),g(ke.$$.fragment,e),_t=!1},d(e){e&&(n(k),n(m),n(v),n(b),n(L),n(Ae),n(D),n(Ne),n(Se),n(X),n(Je),n(B),n(De),n(Oe),n(Xe),n(G),n(Ee),n(Re),n(Y),n(Ge),n(Ve),n(K),n(Ye),n(ee),n(Qe),n(Ke),n(et),n(tt),n(ae),n(nt),n(se),n(ot),n(at),n(ie),n(st),n(rt),n(le),n(it),n(dt),n($),n(lt),n(ct),n(T),n(mt),n(pt),n(j),n(ut),n(ht),n(y),n(ft),n(gt),n(Ue)),n(r),_(C,e),_(O,e),_(E,e),_(R,e),_(V,e),_(Q,e),_(te,e),_(ne,e),_(oe,e),_(re,e),_(de,e),_(ce,e),_(me),_(pe,e),_(ue),_(he),_(U),_(fe,e),_(ge),_(_e),_(A),_(N),_(be,e),_(ye),_(ve),_(S),_(ke,e)}}}const Zn='{"title":"Zamba","local":"zamba","sections":[{"title":"Model details","local":"model-details","sections":[],"depth":2},{"title":"Quick start","local":"quick-start","sections":[{"title":"Presequities","local":"presequities","sections":[],"depth":3}],"depth":2},{"title":"Inference","local":"inference","sections":[],"depth":2},{"title":"Model card","local":"model-card","sections":[],"depth":2},{"title":"Issues","local":"issues","sections":[],"depth":2},{"title":"License","local":"license","sections":[],"depth":2},{"title":"ZambaConfig","local":"transformers.ZambaConfig","sections":[],"depth":2},{"title":"ZambaModel","local":"transformers.ZambaModel","sections":[],"depth":2},{"title":"ZambaForCausalLM","local":"transformers.ZambaForCausalLM","sections":[],"depth":2},{"title":"ZambaForSequenceClassification","local":"transformers.ZambaForSequenceClassification","sections":[],"depth":2}],"depth":1}';function xn(F){return _n(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class Wn extends bn{constructor(r){super(),yn(this,r,xn,zn,fn,{})}}export{Wn as component};
