import{S as xa,i as Pa,s as Sa,e as n,k as h,w as y,t as s,M as Ia,c as a,d as t,m,a as i,x as w,h as r,b as l,G as e,g,y as T,q as k,o as L,B as O,v as qa,L as Ea}from"../../chunks/vendor-hf-doc-builder.js";import{T as Nn}from"../../chunks/Tip-hf-doc-builder.js";import{D as qe}from"../../chunks/Docstring-hf-doc-builder.js";import{C as Fa}from"../../chunks/CodeBlock-hf-doc-builder.js";import{I as oo}from"../../chunks/IconCopyLink-hf-doc-builder.js";import{E as za}from"../../chunks/ExampleCodeBlock-hf-doc-builder.js";function Wa(x){let d,v;return d=new Fa({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyME9wZW5MbGFtYU1vZGVsJTJDJTIwT3BlbkxsYW1hQ29uZmlnJTBBJTBBJTIzJTIwSW5pdGlhbGl6aW5nJTIwYSUyME9wZW4tTGxhbWElMjBvcGVuX2xsYW1hLTdiJTIwc3R5bGUlMjBjb25maWd1cmF0aW9uJTBBY29uZmlndXJhdGlvbiUyMCUzRCUyME9wZW5MbGFtYUNvbmZpZygpJTBBJTBBJTIzJTIwSW5pdGlhbGl6aW5nJTIwYSUyMG1vZGVsJTIwZnJvbSUyMHRoZSUyMG9wZW5fbGxhbWEtN2IlMjBzdHlsZSUyMGNvbmZpZ3VyYXRpb24lMEFtb2RlbCUyMCUzRCUyME9wZW5MbGFtYU1vZGVsKGNvbmZpZ3VyYXRpb24pJTBBJTBBJTIzJTIwQWNjZXNzaW5nJTIwdGhlJTIwbW9kZWwlMjBjb25maWd1cmF0aW9uJTBBY29uZmlndXJhdGlvbiUyMCUzRCUyMG1vZGVsLmNvbmZpZw==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> OpenLlamaModel, OpenLlamaConfig

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Initializing a Open-Llama open_llama-7b style configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>configuration = OpenLlamaConfig()

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Initializing a model from the open_llama-7b style configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>model = OpenLlamaModel(configuration)

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Accessing the model configuration</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>configuration = model.config`}}),{c(){y(d.$$.fragment)},l(c){w(d.$$.fragment,c)},m(c,_){T(d,c,_),v=!0},p:Ea,i(c){v||(k(d.$$.fragment,c),v=!0)},o(c){L(d.$$.fragment,c),v=!1},d(c){O(d,c)}}}function Ja(x){let d,v,c,_,b;return{c(){d=n("p"),v=s("Although the recipe for forward pass needs to be defined within this function, one should call the "),c=n("code"),_=s("Module"),b=s(`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`)},l(p){d=a(p,"P",{});var u=i(d);v=r(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),c=a(u,"CODE",{});var C=i(c);_=r(C,"Module"),C.forEach(t),b=r(u,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),u.forEach(t)},m(p,u){g(p,d,u),e(d,v),e(d,c),e(c,_),e(d,b)},d(p){p&&t(d)}}}function Aa(x){let d,v,c,_,b;return{c(){d=n("p"),v=s("Although the recipe for forward pass needs to be defined within this function, one should call the "),c=n("code"),_=s("Module"),b=s(`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`)},l(p){d=a(p,"P",{});var u=i(d);v=r(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),c=a(u,"CODE",{});var C=i(c);_=r(C,"Module"),C.forEach(t),b=r(u,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),u.forEach(t)},m(p,u){g(p,d,u),e(d,v),e(d,c),e(c,_),e(d,b)},d(p){p&&t(d)}}}function Na(x){let d,v,c,_,b;return _=new Fa({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Ub2tlbml6ZXIlMkMlMjBPcGVuTGxhbWFGb3JDYXVzYWxMTSUwQSUwQW1vZGVsJTIwJTNEJTIwT3BlbkxsYW1hRm9yQ2F1c2FsTE0uZnJvbV9wcmV0cmFpbmVkKFBBVEhfVE9fQ09OVkVSVEVEX1dFSUdIVFMpJTBBdG9rZW5pemVyJTIwJTNEJTIwQXV0b1Rva2VuaXplci5mcm9tX3ByZXRyYWluZWQoUEFUSF9UT19DT05WRVJURURfVE9LRU5JWkVSKSUwQSUwQXByb21wdCUyMCUzRCUyMCUyMkhleSUyQyUyMGFyZSUyMHlvdSUyMGNvbnNjaW91cyUzRiUyMENhbiUyMHlvdSUyMHRhbGslMjB0byUyMG1lJTNGJTIyJTBBaW5wdXRzJTIwJTNEJTIwdG9rZW5pemVyKHByb21wdCUyQyUyMHJldHVybl90ZW5zb3JzJTNEJTIycHQlMjIpJTBBJTBBJTIzJTIwR2VuZXJhdGUlMEFnZW5lcmF0ZV9pZHMlMjAlM0QlMjBtb2RlbC5nZW5lcmF0ZShpbnB1dHMuaW5wdXRfaWRzJTJDJTIwbWF4X2xlbmd0aCUzRDMwKSUwQXRva2VuaXplci5iYXRjaF9kZWNvZGUoZ2VuZXJhdGVfaWRzJTJDJTIwc2tpcF9zcGVjaWFsX3Rva2VucyUzRFRydWUlMkMlMjBjbGVhbl91cF90b2tlbml6YXRpb25fc3BhY2VzJTNERmFsc2UpJTVCMCU1RA==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, OpenLlamaForCausalLM

<span class="hljs-meta">&gt;&gt;&gt; </span>model = OpenLlamaForCausalLM.from_pretrained(PATH_TO_CONVERTED_WEIGHTS)
<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(PATH_TO_CONVERTED_TOKENIZER)

<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>`}}),{c(){d=n("p"),v=s("Example:"),c=h(),y(_.$$.fragment)},l(p){d=a(p,"P",{});var u=i(d);v=r(u,"Example:"),u.forEach(t),c=m(p),w(_.$$.fragment,p)},m(p,u){g(p,d,u),e(d,v),g(p,c,u),T(_,p,u),b=!0},p:Ea,i(p){b||(k(_.$$.fragment,p),b=!0)},o(p){L(_.$$.fragment,p),b=!1},d(p){p&&t(d),p&&t(c),O(_,p)}}}function Ua(x){let d,v,c,_,b;return{c(){d=n("p"),v=s("Although the recipe for forward pass needs to be defined within this function, one should call the "),c=n("code"),_=s("Module"),b=s(`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`)},l(p){d=a(p,"P",{});var u=i(d);v=r(u,"Although the recipe for forward pass needs to be defined within this function, one should call the "),c=a(u,"CODE",{});var C=i(c);_=r(C,"Module"),C.forEach(t),b=r(u,`
instance afterwards instead of this since the former takes care of running the pre and post processing steps while
the latter silently ignores them.`),u.forEach(t)},m(p,u){g(p,d,u),e(d,v),e(d,c),e(c,_),e(d,b)},d(p){p&&t(d)}}}function Va(x){let d,v,c,_,b,p,u,C,Ho,Mo,A,H,to,pe,Yo,no,Qo,Co,Y,Ko,he,et,ot,zo,We,tt,Eo,P,nt,me,at,st,fe,rt,it,ue,lt,dt,Fo,N,Q,ao,ge,ct,so,pt,xo,E,_e,ht,U,mt,Je,ft,ut,ve,gt,_t,vt,V,bt,Ae,yt,wt,Ne,Tt,kt,Lt,K,Po,j,ee,ro,be,Ot,io,$t,So,M,ye,Mt,we,Ct,Ue,zt,Et,Ft,Te,xt,ke,Pt,St,It,oe,qt,lo,Wt,Jt,co,At,Nt,I,Le,Ut,B,Vt,Ve,jt,Bt,po,Gt,Zt,Dt,te,Io,G,ne,ho,Oe,Rt,mo,Xt,qo,Z,$e,Ht,S,Me,Yt,D,Qt,je,Kt,en,fo,on,tn,nn,ae,an,se,Wo,R,re,uo,Ce,sn,go,rn,Jo,$,ze,ln,_o,dn,cn,Be,Ge,pn,hn,mn,F,fn,vo,un,gn,bo,_n,vn,yo,bn,yn,wo,wn,Tn,kn,Ee,Ln,Ze,On,$n,Mn,Fe,Cn,xe,zn,En,Fn,q,Pe,xn,X,Pn,De,Sn,In,To,qn,Wn,Jn,ie,Ao;return p=new oo({}),pe=new oo({}),ge=new oo({}),_e=new qe({props:{name:"class transformers.OpenLlamaConfig",anchor:"transformers.OpenLlamaConfig",parameters:[{name:"vocab_size",val:" = 100000"},{name:"hidden_size",val:" = 4096"},{name:"intermediate_size",val:" = 11008"},{name:"num_hidden_layers",val:" = 32"},{name:"num_attention_heads",val:" = 32"},{name:"hidden_act",val:" = 'silu'"},{name:"max_position_embeddings",val:" = 2048"},{name:"initializer_range",val:" = 0.02"},{name:"rms_norm_eps",val:" = 1e-06"},{name:"use_cache",val:" = True"},{name:"pad_token_id",val:" = 0"},{name:"bos_token_id",val:" = 1"},{name:"eos_token_id",val:" = 2"},{name:"tie_word_embeddings",val:" = False"},{name:"use_memory_efficient_attention",val:" = True"},{name:"hidden_dropout_prob",val:" = 0.1"},{name:"attention_dropout_prob",val:" = 0.1"},{name:"use_stable_embedding",val:" = True"},{name:"shared_input_output_embedding",val:" = True"},{name:"rope_scaling",val:" = None"},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"transformers.OpenLlamaConfig.vocab_size",description:`<strong>vocab_size</strong> (<code>int</code>, <em>optional</em>, defaults to 32000) &#x2014;
Vocabulary size of the Open-Llama model. Defines the number of different tokens that can be represented by
the <code>inputs_ids</code> passed when calling <a href="/docs/transformers/v4.31.0/en/model_doc/open-llama#transformers.OpenLlamaModel">OpenLlamaModel</a>`,name:"vocab_size"},{anchor:"transformers.OpenLlamaConfig.hidden_size",description:`<strong>hidden_size</strong> (<code>int</code>, <em>optional</em>, defaults to 4096) &#x2014;
Dimension of the hidden representations.`,name:"hidden_size"},{anchor:"transformers.OpenLlamaConfig.intermediate_size",description:`<strong>intermediate_size</strong> (<code>int</code>, <em>optional</em>, defaults to 11008) &#x2014;
Dimension of the MLP representations.`,name:"intermediate_size"},{anchor:"transformers.OpenLlamaConfig.num_hidden_layers",description:`<strong>num_hidden_layers</strong> (<code>int</code>, <em>optional</em>, defaults to 32) &#x2014;
Number of hidden layers in the Transformer encoder.`,name:"num_hidden_layers"},{anchor:"transformers.OpenLlamaConfig.num_attention_heads",description:`<strong>num_attention_heads</strong> (<code>int</code>, <em>optional</em>, defaults to 32) &#x2014;
Number of attention heads for each attention layer in the Transformer encoder.`,name:"num_attention_heads"},{anchor:"transformers.OpenLlamaConfig.hidden_act",description:`<strong>hidden_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 decoder.`,name:"hidden_act"},{anchor:"transformers.OpenLlamaConfig.max_position_embeddings",description:`<strong>max_position_embeddings</strong> (<code>int</code>, <em>optional</em>, defaults to 2048) &#x2014;
The maximum sequence length that this model might ever be used with. Typically set this to something large
just in case (e.g., 512 or 1024 or 2048).`,name:"max_position_embeddings"},{anchor:"transformers.OpenLlamaConfig.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.OpenLlamaConfig.rms_norm_eps",description:`<strong>rms_norm_eps</strong> (<code>float</code>, <em>optional</em>, defaults to 1e-12) &#x2014;
The epsilon used by the rms normalization layers.`,name:"rms_norm_eps"},{anchor:"transformers.OpenLlamaConfig.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.OpenLlamaConfig.tie_word_embeddings(bool,",description:`<strong>tie_word_embeddings(<code>bool</code>,</strong> <em>optional</em>, defaults to <code>False</code>) &#x2014;
Whether to tie weight embeddings`,name:"tie_word_embeddings(bool,"},{anchor:"transformers.OpenLlamaConfig.rope_scaling",description:`<strong>rope_scaling</strong> (<code>Dict</code>, <em>optional</em>) &#x2014;
Dictionary containing the scaling configuration for the RoPE embeddings. Currently supports three scaling
strategies: linear and dynamic. Their scaling factor must be an float greater than 1. The expected format
is <code>{&quot;type&quot;: strategy name, &quot;factor&quot;: scaling factor}</code>. When using this flag, don&#x2019;t update
<code>max_position_embeddings</code> to the expected new maximum. See the following thread for more information on how
these scaling strategies behave:
<a href="https://www.reddit.com/r/LocalLLaMA/comments/14mrgpr/dynamically_scaled_rope_further_increases/" rel="nofollow">https://www.reddit.com/r/LocalLLaMA/comments/14mrgpr/dynamically_scaled_rope_further_increases/</a>. This is an
experimental feature, subject to breaking API changes in future versions.</p>
<p>Example &#x2014;`,name:"rope_scaling"}],source:"https://github.com/huggingface/transformers/blob/v4.31.0/src/transformers/models/open_llama/configuration_open_llama.py#L33"}}),K=new za({props:{anchor:"transformers.OpenLlamaConfig.example",$$slots:{default:[Wa]},$$scope:{ctx:x}}}),be=new oo({}),ye=new qe({props:{name:"class transformers.OpenLlamaModel",anchor:"transformers.OpenLlamaModel",parameters:[{name:"config",val:": OpenLlamaConfig"}],parametersDescription:[{anchor:"transformers.OpenLlamaModel.config",description:`<strong>config</strong> (<a href="/docs/transformers/v4.31.0/en/model_doc/open-llama#transformers.OpenLlamaConfig">OpenLlamaConfig</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/v4.31.0/en/main_classes/model#transformers.PreTrainedModel.from_pretrained">from_pretrained()</a> method to load the model weights.
config &#x2014; OpenLlamaConfig`,name:"config"}],source:"https://github.com/huggingface/transformers/blob/v4.31.0/src/transformers/models/open_llama/modeling_open_llama.py#L529"}}),Le=new qe({props:{name:"forward",anchor:"transformers.OpenLlamaModel.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[typing.List[torch.FloatTensor]] = 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"}],parametersDescription:[{anchor:"transformers.OpenLlamaModel.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/v4.31.0/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.31.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.31.0/en/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.__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.OpenLlamaModel.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/v4.31.0/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.31.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.31.0/en/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p>If <code>past_key_values</code> is used, optionally only the last <code>decoder_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.OpenLlamaModel.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.OpenLlamaModel.forward.past_key_values",description:`<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>) &#x2014;
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>) and 2 additional tensors of shape
<code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
blocks) that can be used (see <code>past_key_values</code> input) to speed up sequential decoding.</p>
<p>If <code>past_key_values</code> are used, the user can optionally input only the last <code>decoder_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>decoder_input_ids</code> of shape <code>(batch_size, sequence_length)</code>.`,name:"past_key_values"},{anchor:"transformers.OpenLlamaModel.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.OpenLlamaModel.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.OpenLlamaModel.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.OpenLlamaModel.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.OpenLlamaModel.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/v4.31.0/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/v4.31.0/src/transformers/models/open_llama/modeling_open_llama.py#L584"}}),te=new Nn({props:{$$slots:{default:[Ja]},$$scope:{ctx:x}}}),Oe=new oo({}),$e=new qe({props:{name:"class transformers.OpenLlamaForCausalLM",anchor:"transformers.OpenLlamaForCausalLM",parameters:[{name:"config",val:""}],source:"https://github.com/huggingface/transformers/blob/v4.31.0/src/transformers/models/open_llama/modeling_open_llama.py#L717"}}),Me=new qe({props:{name:"forward",anchor:"transformers.OpenLlamaForCausalLM.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[typing.List[torch.FloatTensor]] = 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.OpenLlamaForCausalLM.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/v4.31.0/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.31.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.31.0/en/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.__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.OpenLlamaForCausalLM.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/v4.31.0/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.31.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.31.0/en/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p>If <code>past_key_values</code> is used, optionally only the last <code>decoder_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.OpenLlamaForCausalLM.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.OpenLlamaForCausalLM.forward.past_key_values",description:`<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>) &#x2014;
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>) and 2 additional tensors of shape
<code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
blocks) that can be used (see <code>past_key_values</code> input) to speed up sequential decoding.</p>
<p>If <code>past_key_values</code> are used, the user can optionally input only the last <code>decoder_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>decoder_input_ids</code> of shape <code>(batch_size, sequence_length)</code>.`,name:"past_key_values"},{anchor:"transformers.OpenLlamaForCausalLM.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.OpenLlamaForCausalLM.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.OpenLlamaForCausalLM.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.OpenLlamaForCausalLM.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.OpenLlamaForCausalLM.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/v4.31.0/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.</p>
<p>Args &#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>.`,name:"return_dict"}],source:"https://github.com/huggingface/transformers/blob/v4.31.0/src/transformers/models/open_llama/modeling_open_llama.py#L747",returnDescription:`
<p>A <a
  href="/docs/transformers/v4.31.0/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/v4.31.0/en/model_doc/open-llama#transformers.OpenLlamaConfig"
>OpenLlamaConfig</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) \u2014 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>) \u2014 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>) \u2014 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>) \u2014 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>) \u2014 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:`
<p><a
  href="/docs/transformers/v4.31.0/en/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast"
>transformers.modeling_outputs.CausalLMOutputWithPast</a> or <code>tuple(torch.FloatTensor)</code></p>
`}}),ae=new Nn({props:{$$slots:{default:[Aa]},$$scope:{ctx:x}}}),se=new za({props:{anchor:"transformers.OpenLlamaForCausalLM.forward.example",$$slots:{default:[Na]},$$scope:{ctx:x}}}),Ce=new oo({}),ze=new qe({props:{name:"class transformers.OpenLlamaForSequenceClassification",anchor:"transformers.OpenLlamaForSequenceClassification",parameters:[{name:"config",val:""}],parametersDescription:[{anchor:"transformers.OpenLlamaForSequenceClassification.config",description:`<strong>config</strong> (<a href="/docs/transformers/v4.31.0/en/model_doc/open-llama#transformers.OpenLlamaConfig">OpenLlamaConfig</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/v4.31.0/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/v4.31.0/src/transformers/models/open_llama/modeling_open_llama.py#L896"}}),Pe=new qe({props:{name:"forward",anchor:"transformers.OpenLlamaForSequenceClassification.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[typing.List[torch.FloatTensor]] = 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.OpenLlamaForSequenceClassification.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/v4.31.0/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.31.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.31.0/en/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.__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.OpenLlamaForSequenceClassification.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/v4.31.0/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a>. See <a href="/docs/transformers/v4.31.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> and
<a href="/docs/transformers/v4.31.0/en/model_doc/wav2vec2#transformers.Wav2Vec2CTCTokenizer.__call__">PreTrainedTokenizer.<strong>call</strong>()</a> for details.</p>
<p>If <code>past_key_values</code> is used, optionally only the last <code>decoder_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.OpenLlamaForSequenceClassification.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.OpenLlamaForSequenceClassification.forward.past_key_values",description:`<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>) &#x2014;
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>) and 2 additional tensors of shape
<code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
blocks) that can be used (see <code>past_key_values</code> input) to speed up sequential decoding.</p>
<p>If <code>past_key_values</code> are used, the user can optionally input only the last <code>decoder_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>decoder_input_ids</code> of shape <code>(batch_size, sequence_length)</code>.`,name:"past_key_values"},{anchor:"transformers.OpenLlamaForSequenceClassification.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.OpenLlamaForSequenceClassification.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.OpenLlamaForSequenceClassification.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.OpenLlamaForSequenceClassification.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.OpenLlamaForSequenceClassification.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/v4.31.0/en/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a> instead of a plain tuple.`,name:"return_dict"},{anchor:"transformers.OpenLlamaForSequenceClassification.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/v4.31.0/src/transformers/models/open_llama/modeling_open_llama.py#L912"}}),ie=new Nn({props:{$$slots:{default:[Ua]},$$scope:{ctx:x}}}),{c(){d=n("meta"),v=h(),c=n("h1"),_=n("a"),b=n("span"),y(p.$$.fragment),u=h(),C=n("span"),Ho=s("Open-Llama"),Mo=h(),A=n("h2"),H=n("a"),to=n("span"),y(pe.$$.fragment),Yo=h(),no=n("span"),Qo=s("Overview"),Co=h(),Y=n("p"),Ko=s("The Open-Llama model was proposed in "),he=n("a"),et=s("Open-Llama project"),ot=s(" by community developer s-JoL."),zo=h(),We=n("p"),tt=s(`The model is mainly based on LLaMA with some modifications, incorporating memory-efficient attention from Xformers, stable embedding from Bloom, and shared input-output embedding from PaLM.
And the model is pre-trained on both Chinese and English, which gives it better performance on Chinese language tasks.`),Eo=h(),P=n("p"),nt=s("This model was contributed by "),me=n("a"),at=s("s-JoL"),st=s(`.
The original code can be found `),fe=n("a"),rt=s("Open-Llama"),it=s(`.
Checkpoint and usage can be found at `),ue=n("a"),lt=s("s-JoL/Open-Llama-V1"),dt=s("."),Fo=h(),N=n("h2"),Q=n("a"),ao=n("span"),y(ge.$$.fragment),ct=h(),so=n("span"),pt=s("OpenLlamaConfig"),xo=h(),E=n("div"),y(_e.$$.fragment),ht=h(),U=n("p"),mt=s("This is the configuration class to store the configuration of a "),Je=n("a"),ft=s("OpenLlamaModel"),ut=s(`. It is used to instantiate an
Open-Llama 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
`),ve=n("a"),gt=s("s-JoL/Open-Llama-V1"),_t=s("."),vt=h(),V=n("p"),bt=s("Configuration objects inherit from "),Ae=n("a"),yt=s("PretrainedConfig"),wt=s(` and can be used to control the model outputs. Read the
documentation from `),Ne=n("a"),Tt=s("PretrainedConfig"),kt=s(" for more information."),Lt=h(),y(K.$$.fragment),Po=h(),j=n("h2"),ee=n("a"),ro=n("span"),y(be.$$.fragment),Ot=h(),io=n("span"),$t=s("OpenLlamaModel"),So=h(),M=n("div"),y(ye.$$.fragment),Mt=h(),we=n("p"),Ct=s(`The bare Open-Llama Model outputting raw hidden-states without any specific head on top.
This model inherits from `),Ue=n("a"),zt=s("PreTrainedModel"),Et=s(`. 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.)`),Ft=h(),Te=n("p"),xt=s("This model is also a PyTorch "),ke=n("a"),Pt=s("torch.nn.Module"),St=s(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),It=h(),oe=n("p"),qt=s("Transformer decoder consisting of "),lo=n("em"),Wt=s("config.num_hidden_layers"),Jt=s(" layers. Each layer is a "),co=n("code"),At=s("OpenLlamaDecoderLayer"),Nt=h(),I=n("div"),y(Le.$$.fragment),Ut=h(),B=n("p"),Vt=s("The "),Ve=n("a"),jt=s("OpenLlamaModel"),Bt=s(" forward method, overrides the "),po=n("code"),Gt=s("__call__"),Zt=s(" special method."),Dt=h(),y(te.$$.fragment),Io=h(),G=n("h2"),ne=n("a"),ho=n("span"),y(Oe.$$.fragment),Rt=h(),mo=n("span"),Xt=s("OpenLlamaForCausalLM"),qo=h(),Z=n("div"),y($e.$$.fragment),Ht=h(),S=n("div"),y(Me.$$.fragment),Yt=h(),D=n("p"),Qt=s("The "),je=n("a"),Kt=s("OpenLlamaForCausalLM"),en=s(" forward method, overrides the "),fo=n("code"),on=s("__call__"),tn=s(" special method."),nn=h(),y(ae.$$.fragment),an=h(),y(se.$$.fragment),Wo=h(),R=n("h2"),re=n("a"),uo=n("span"),y(Ce.$$.fragment),sn=h(),go=n("span"),rn=s("OpenLlamaForSequenceClassification"),Jo=h(),$=n("div"),y(ze.$$.fragment),ln=h(),_o=n("p"),dn=s("The LLaMa Model transformer with a sequence classification head on top (linear layer)."),cn=h(),Be=n("p"),Ge=n("a"),pn=s("OpenLlamaForSequenceClassification"),hn=s(` uses the last token in order to do the classification, as other causal
models (e.g. GPT-2) do.`),mn=h(),F=n("p"),fn=s(`Since it does classification on the last token, it requires to know the position of the last token. If a
`),vo=n("code"),un=s("pad_token_id"),gn=s(` is defined in the configuration, it finds the last token that is not a padding token in each row. If
no `),bo=n("code"),_n=s("pad_token_id"),vn=s(` is defined, it simply takes the last value in each row of the batch. Since it cannot guess the
padding tokens when `),yo=n("code"),bn=s("inputs_embeds"),yn=s(" are passed instead of "),wo=n("code"),wn=s("input_ids"),Tn=s(`, it does the same (take the last value in
each row of the batch).`),kn=h(),Ee=n("p"),Ln=s("This model inherits from "),Ze=n("a"),On=s("PreTrainedModel"),$n=s(`. 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.)`),Mn=h(),Fe=n("p"),Cn=s("This model is also a PyTorch "),xe=n("a"),zn=s("torch.nn.Module"),En=s(` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),Fn=h(),q=n("div"),y(Pe.$$.fragment),xn=h(),X=n("p"),Pn=s("The "),De=n("a"),Sn=s("OpenLlamaForSequenceClassification"),In=s(" forward method, overrides the "),To=n("code"),qn=s("__call__"),Wn=s(" special method."),Jn=h(),y(ie.$$.fragment),this.h()},l(o){const f=Ia('[data-svelte="svelte-1phssyn"]',document.head);d=a(f,"META",{name:!0,content:!0}),f.forEach(t),v=m(o),c=a(o,"H1",{class:!0});var Se=i(c);_=a(Se,"A",{id:!0,class:!0,href:!0});var ko=i(_);b=a(ko,"SPAN",{});var Lo=i(b);w(p.$$.fragment,Lo),Lo.forEach(t),ko.forEach(t),u=m(Se),C=a(Se,"SPAN",{});var Oo=i(C);Ho=r(Oo,"Open-Llama"),Oo.forEach(t),Se.forEach(t),Mo=m(o),A=a(o,"H2",{class:!0});var Ie=i(A);H=a(Ie,"A",{id:!0,class:!0,href:!0});var Un=i(H);to=a(Un,"SPAN",{});var Vn=i(to);w(pe.$$.fragment,Vn),Vn.forEach(t),Un.forEach(t),Yo=m(Ie),no=a(Ie,"SPAN",{});var jn=i(no);Qo=r(jn,"Overview"),jn.forEach(t),Ie.forEach(t),Co=m(o),Y=a(o,"P",{});var No=i(Y);Ko=r(No,"The Open-Llama model was proposed in "),he=a(No,"A",{href:!0,rel:!0});var Bn=i(he);et=r(Bn,"Open-Llama project"),Bn.forEach(t),ot=r(No," by community developer s-JoL."),No.forEach(t),zo=m(o),We=a(o,"P",{});var Gn=i(We);tt=r(Gn,`The model is mainly based on LLaMA with some modifications, incorporating memory-efficient attention from Xformers, stable embedding from Bloom, and shared input-output embedding from PaLM.
And the model is pre-trained on both Chinese and English, which gives it better performance on Chinese language tasks.`),Gn.forEach(t),Eo=m(o),P=a(o,"P",{});var le=i(P);nt=r(le,"This model was contributed by "),me=a(le,"A",{href:!0,rel:!0});var Zn=i(me);at=r(Zn,"s-JoL"),Zn.forEach(t),st=r(le,`.
The original code can be found `),fe=a(le,"A",{href:!0,rel:!0});var Dn=i(fe);rt=r(Dn,"Open-Llama"),Dn.forEach(t),it=r(le,`.
Checkpoint and usage can be found at `),ue=a(le,"A",{href:!0,rel:!0});var Rn=i(ue);lt=r(Rn,"s-JoL/Open-Llama-V1"),Rn.forEach(t),dt=r(le,"."),le.forEach(t),Fo=m(o),N=a(o,"H2",{class:!0});var Uo=i(N);Q=a(Uo,"A",{id:!0,class:!0,href:!0});var Xn=i(Q);ao=a(Xn,"SPAN",{});var Hn=i(ao);w(ge.$$.fragment,Hn),Hn.forEach(t),Xn.forEach(t),ct=m(Uo),so=a(Uo,"SPAN",{});var Yn=i(so);pt=r(Yn,"OpenLlamaConfig"),Yn.forEach(t),Uo.forEach(t),xo=m(o),E=a(o,"DIV",{class:!0});var de=i(E);w(_e.$$.fragment,de),ht=m(de),U=a(de,"P",{});var Re=i(U);mt=r(Re,"This is the configuration class to store the configuration of a "),Je=a(Re,"A",{href:!0});var Qn=i(Je);ft=r(Qn,"OpenLlamaModel"),Qn.forEach(t),ut=r(Re,`. It is used to instantiate an
Open-Llama 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
`),ve=a(Re,"A",{href:!0,rel:!0});var Kn=i(ve);gt=r(Kn,"s-JoL/Open-Llama-V1"),Kn.forEach(t),_t=r(Re,"."),Re.forEach(t),vt=m(de),V=a(de,"P",{});var Xe=i(V);bt=r(Xe,"Configuration objects inherit from "),Ae=a(Xe,"A",{href:!0});var ea=i(Ae);yt=r(ea,"PretrainedConfig"),ea.forEach(t),wt=r(Xe,` and can be used to control the model outputs. Read the
documentation from `),Ne=a(Xe,"A",{href:!0});var oa=i(Ne);Tt=r(oa,"PretrainedConfig"),oa.forEach(t),kt=r(Xe," for more information."),Xe.forEach(t),Lt=m(de),w(K.$$.fragment,de),de.forEach(t),Po=m(o),j=a(o,"H2",{class:!0});var Vo=i(j);ee=a(Vo,"A",{id:!0,class:!0,href:!0});var ta=i(ee);ro=a(ta,"SPAN",{});var na=i(ro);w(be.$$.fragment,na),na.forEach(t),ta.forEach(t),Ot=m(Vo),io=a(Vo,"SPAN",{});var aa=i(io);$t=r(aa,"OpenLlamaModel"),aa.forEach(t),Vo.forEach(t),So=m(o),M=a(o,"DIV",{class:!0});var W=i(M);w(ye.$$.fragment,W),Mt=m(W),we=a(W,"P",{});var jo=i(we);Ct=r(jo,`The bare Open-Llama Model outputting raw hidden-states without any specific head on top.
This model inherits from `),Ue=a(jo,"A",{href:!0});var sa=i(Ue);zt=r(sa,"PreTrainedModel"),sa.forEach(t),Et=r(jo,`. 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.)`),jo.forEach(t),Ft=m(W),Te=a(W,"P",{});var Bo=i(Te);xt=r(Bo,"This model is also a PyTorch "),ke=a(Bo,"A",{href:!0,rel:!0});var ra=i(ke);Pt=r(ra,"torch.nn.Module"),ra.forEach(t),St=r(Bo,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),Bo.forEach(t),It=m(W),oe=a(W,"P",{});var $o=i(oe);qt=r($o,"Transformer decoder consisting of "),lo=a($o,"EM",{});var ia=i(lo);Wt=r(ia,"config.num_hidden_layers"),ia.forEach(t),Jt=r($o," layers. Each layer is a "),co=a($o,"CODE",{});var la=i(co);At=r(la,"OpenLlamaDecoderLayer"),la.forEach(t),$o.forEach(t),Nt=m(W),I=a(W,"DIV",{class:!0});var He=i(I);w(Le.$$.fragment,He),Ut=m(He),B=a(He,"P",{});var Ye=i(B);Vt=r(Ye,"The "),Ve=a(Ye,"A",{href:!0});var da=i(Ve);jt=r(da,"OpenLlamaModel"),da.forEach(t),Bt=r(Ye," forward method, overrides the "),po=a(Ye,"CODE",{});var ca=i(po);Gt=r(ca,"__call__"),ca.forEach(t),Zt=r(Ye," special method."),Ye.forEach(t),Dt=m(He),w(te.$$.fragment,He),He.forEach(t),W.forEach(t),Io=m(o),G=a(o,"H2",{class:!0});var Go=i(G);ne=a(Go,"A",{id:!0,class:!0,href:!0});var pa=i(ne);ho=a(pa,"SPAN",{});var ha=i(ho);w(Oe.$$.fragment,ha),ha.forEach(t),pa.forEach(t),Rt=m(Go),mo=a(Go,"SPAN",{});var ma=i(mo);Xt=r(ma,"OpenLlamaForCausalLM"),ma.forEach(t),Go.forEach(t),qo=m(o),Z=a(o,"DIV",{class:!0});var Zo=i(Z);w($e.$$.fragment,Zo),Ht=m(Zo),S=a(Zo,"DIV",{class:!0});var ce=i(S);w(Me.$$.fragment,ce),Yt=m(ce),D=a(ce,"P",{});var Qe=i(D);Qt=r(Qe,"The "),je=a(Qe,"A",{href:!0});var fa=i(je);Kt=r(fa,"OpenLlamaForCausalLM"),fa.forEach(t),en=r(Qe," forward method, overrides the "),fo=a(Qe,"CODE",{});var ua=i(fo);on=r(ua,"__call__"),ua.forEach(t),tn=r(Qe," special method."),Qe.forEach(t),nn=m(ce),w(ae.$$.fragment,ce),an=m(ce),w(se.$$.fragment,ce),ce.forEach(t),Zo.forEach(t),Wo=m(o),R=a(o,"H2",{class:!0});var Do=i(R);re=a(Do,"A",{id:!0,class:!0,href:!0});var ga=i(re);uo=a(ga,"SPAN",{});var _a=i(uo);w(Ce.$$.fragment,_a),_a.forEach(t),ga.forEach(t),sn=m(Do),go=a(Do,"SPAN",{});var va=i(go);rn=r(va,"OpenLlamaForSequenceClassification"),va.forEach(t),Do.forEach(t),Jo=m(o),$=a(o,"DIV",{class:!0});var z=i($);w(ze.$$.fragment,z),ln=m(z),_o=a(z,"P",{});var ba=i(_o);dn=r(ba,"The LLaMa Model transformer with a sequence classification head on top (linear layer)."),ba.forEach(t),cn=m(z),Be=a(z,"P",{});var An=i(Be);Ge=a(An,"A",{href:!0});var ya=i(Ge);pn=r(ya,"OpenLlamaForSequenceClassification"),ya.forEach(t),hn=r(An,` uses the last token in order to do the classification, as other causal
models (e.g. GPT-2) do.`),An.forEach(t),mn=m(z),F=a(z,"P",{});var J=i(F);fn=r(J,`Since it does classification on the last token, it requires to know the position of the last token. If a
`),vo=a(J,"CODE",{});var wa=i(vo);un=r(wa,"pad_token_id"),wa.forEach(t),gn=r(J,` is defined in the configuration, it finds the last token that is not a padding token in each row. If
no `),bo=a(J,"CODE",{});var Ta=i(bo);_n=r(Ta,"pad_token_id"),Ta.forEach(t),vn=r(J,` is defined, it simply takes the last value in each row of the batch. Since it cannot guess the
padding tokens when `),yo=a(J,"CODE",{});var ka=i(yo);bn=r(ka,"inputs_embeds"),ka.forEach(t),yn=r(J," are passed instead of "),wo=a(J,"CODE",{});var La=i(wo);wn=r(La,"input_ids"),La.forEach(t),Tn=r(J,`, it does the same (take the last value in
each row of the batch).`),J.forEach(t),kn=m(z),Ee=a(z,"P",{});var Ro=i(Ee);Ln=r(Ro,"This model inherits from "),Ze=a(Ro,"A",{href:!0});var Oa=i(Ze);On=r(Oa,"PreTrainedModel"),Oa.forEach(t),$n=r(Ro,`. 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.)`),Ro.forEach(t),Mn=m(z),Fe=a(z,"P",{});var Xo=i(Fe);Cn=r(Xo,"This model is also a PyTorch "),xe=a(Xo,"A",{href:!0,rel:!0});var $a=i(xe);zn=r($a,"torch.nn.Module"),$a.forEach(t),En=r(Xo,` subclass.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
and behavior.`),Xo.forEach(t),Fn=m(z),q=a(z,"DIV",{class:!0});var Ke=i(q);w(Pe.$$.fragment,Ke),xn=m(Ke),X=a(Ke,"P",{});var eo=i(X);Pn=r(eo,"The "),De=a(eo,"A",{href:!0});var Ma=i(De);Sn=r(Ma,"OpenLlamaForSequenceClassification"),Ma.forEach(t),In=r(eo," forward method, overrides the "),To=a(eo,"CODE",{});var Ca=i(To);qn=r(Ca,"__call__"),Ca.forEach(t),Wn=r(eo," special method."),eo.forEach(t),Jn=m(Ke),w(ie.$$.fragment,Ke),Ke.forEach(t),z.forEach(t),this.h()},h(){l(d,"name","hf:doc:metadata"),l(d,"content",JSON.stringify(ja)),l(_,"id","openllama"),l(_,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),l(_,"href","#openllama"),l(c,"class","relative group"),l(H,"id","overview"),l(H,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),l(H,"href","#overview"),l(A,"class","relative group"),l(he,"href","https://github.com/s-JoL/Open-Llama"),l(he,"rel","nofollow"),l(me,"href","https://huggingface.co/s-JoL"),l(me,"rel","nofollow"),l(fe,"href","https://github.com/s-JoL/Open-Llama"),l(fe,"rel","nofollow"),l(ue,"href","https://huggingface.co/s-JoL/Open-Llama-V1"),l(ue,"rel","nofollow"),l(Q,"id","transformers.OpenLlamaConfig"),l(Q,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),l(Q,"href","#transformers.OpenLlamaConfig"),l(N,"class","relative group"),l(Je,"href","/docs/transformers/v4.31.0/en/model_doc/open-llama#transformers.OpenLlamaModel"),l(ve,"href","https://huggingface.co/s-JoL/Open-Llama-V1"),l(ve,"rel","nofollow"),l(Ae,"href","/docs/transformers/v4.31.0/en/main_classes/configuration#transformers.PretrainedConfig"),l(Ne,"href","/docs/transformers/v4.31.0/en/main_classes/configuration#transformers.PretrainedConfig"),l(E,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),l(ee,"id","transformers.OpenLlamaModel"),l(ee,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),l(ee,"href","#transformers.OpenLlamaModel"),l(j,"class","relative group"),l(Ue,"href","/docs/transformers/v4.31.0/en/main_classes/model#transformers.PreTrainedModel"),l(ke,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),l(ke,"rel","nofollow"),l(Ve,"href","/docs/transformers/v4.31.0/en/model_doc/open-llama#transformers.OpenLlamaModel"),l(I,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),l(M,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),l(ne,"id","transformers.OpenLlamaForCausalLM"),l(ne,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),l(ne,"href","#transformers.OpenLlamaForCausalLM"),l(G,"class","relative group"),l(je,"href","/docs/transformers/v4.31.0/en/model_doc/open-llama#transformers.OpenLlamaForCausalLM"),l(S,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),l(Z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),l(re,"id","transformers.OpenLlamaForSequenceClassification"),l(re,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),l(re,"href","#transformers.OpenLlamaForSequenceClassification"),l(R,"class","relative group"),l(Ge,"href","/docs/transformers/v4.31.0/en/model_doc/open-llama#transformers.OpenLlamaForSequenceClassification"),l(Ze,"href","/docs/transformers/v4.31.0/en/main_classes/model#transformers.PreTrainedModel"),l(xe,"href","https://pytorch.org/docs/stable/nn.html#torch.nn.Module"),l(xe,"rel","nofollow"),l(De,"href","/docs/transformers/v4.31.0/en/model_doc/open-llama#transformers.OpenLlamaForSequenceClassification"),l(q,"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")},m(o,f){e(document.head,d),g(o,v,f),g(o,c,f),e(c,_),e(_,b),T(p,b,null),e(c,u),e(c,C),e(C,Ho),g(o,Mo,f),g(o,A,f),e(A,H),e(H,to),T(pe,to,null),e(A,Yo),e(A,no),e(no,Qo),g(o,Co,f),g(o,Y,f),e(Y,Ko),e(Y,he),e(he,et),e(Y,ot),g(o,zo,f),g(o,We,f),e(We,tt),g(o,Eo,f),g(o,P,f),e(P,nt),e(P,me),e(me,at),e(P,st),e(P,fe),e(fe,rt),e(P,it),e(P,ue),e(ue,lt),e(P,dt),g(o,Fo,f),g(o,N,f),e(N,Q),e(Q,ao),T(ge,ao,null),e(N,ct),e(N,so),e(so,pt),g(o,xo,f),g(o,E,f),T(_e,E,null),e(E,ht),e(E,U),e(U,mt),e(U,Je),e(Je,ft),e(U,ut),e(U,ve),e(ve,gt),e(U,_t),e(E,vt),e(E,V),e(V,bt),e(V,Ae),e(Ae,yt),e(V,wt),e(V,Ne),e(Ne,Tt),e(V,kt),e(E,Lt),T(K,E,null),g(o,Po,f),g(o,j,f),e(j,ee),e(ee,ro),T(be,ro,null),e(j,Ot),e(j,io),e(io,$t),g(o,So,f),g(o,M,f),T(ye,M,null),e(M,Mt),e(M,we),e(we,Ct),e(we,Ue),e(Ue,zt),e(we,Et),e(M,Ft),e(M,Te),e(Te,xt),e(Te,ke),e(ke,Pt),e(Te,St),e(M,It),e(M,oe),e(oe,qt),e(oe,lo),e(lo,Wt),e(oe,Jt),e(oe,co),e(co,At),e(M,Nt),e(M,I),T(Le,I,null),e(I,Ut),e(I,B),e(B,Vt),e(B,Ve),e(Ve,jt),e(B,Bt),e(B,po),e(po,Gt),e(B,Zt),e(I,Dt),T(te,I,null),g(o,Io,f),g(o,G,f),e(G,ne),e(ne,ho),T(Oe,ho,null),e(G,Rt),e(G,mo),e(mo,Xt),g(o,qo,f),g(o,Z,f),T($e,Z,null),e(Z,Ht),e(Z,S),T(Me,S,null),e(S,Yt),e(S,D),e(D,Qt),e(D,je),e(je,Kt),e(D,en),e(D,fo),e(fo,on),e(D,tn),e(S,nn),T(ae,S,null),e(S,an),T(se,S,null),g(o,Wo,f),g(o,R,f),e(R,re),e(re,uo),T(Ce,uo,null),e(R,sn),e(R,go),e(go,rn),g(o,Jo,f),g(o,$,f),T(ze,$,null),e($,ln),e($,_o),e(_o,dn),e($,cn),e($,Be),e(Be,Ge),e(Ge,pn),e(Be,hn),e($,mn),e($,F),e(F,fn),e(F,vo),e(vo,un),e(F,gn),e(F,bo),e(bo,_n),e(F,vn),e(F,yo),e(yo,bn),e(F,yn),e(F,wo),e(wo,wn),e(F,Tn),e($,kn),e($,Ee),e(Ee,Ln),e(Ee,Ze),e(Ze,On),e(Ee,$n),e($,Mn),e($,Fe),e(Fe,Cn),e(Fe,xe),e(xe,zn),e(Fe,En),e($,Fn),e($,q),T(Pe,q,null),e(q,xn),e(q,X),e(X,Pn),e(X,De),e(De,Sn),e(X,In),e(X,To),e(To,qn),e(X,Wn),e(q,Jn),T(ie,q,null),Ao=!0},p(o,[f]){const Se={};f&2&&(Se.$$scope={dirty:f,ctx:o}),K.$set(Se);const ko={};f&2&&(ko.$$scope={dirty:f,ctx:o}),te.$set(ko);const Lo={};f&2&&(Lo.$$scope={dirty:f,ctx:o}),ae.$set(Lo);const Oo={};f&2&&(Oo.$$scope={dirty:f,ctx:o}),se.$set(Oo);const Ie={};f&2&&(Ie.$$scope={dirty:f,ctx:o}),ie.$set(Ie)},i(o){Ao||(k(p.$$.fragment,o),k(pe.$$.fragment,o),k(ge.$$.fragment,o),k(_e.$$.fragment,o),k(K.$$.fragment,o),k(be.$$.fragment,o),k(ye.$$.fragment,o),k(Le.$$.fragment,o),k(te.$$.fragment,o),k(Oe.$$.fragment,o),k($e.$$.fragment,o),k(Me.$$.fragment,o),k(ae.$$.fragment,o),k(se.$$.fragment,o),k(Ce.$$.fragment,o),k(ze.$$.fragment,o),k(Pe.$$.fragment,o),k(ie.$$.fragment,o),Ao=!0)},o(o){L(p.$$.fragment,o),L(pe.$$.fragment,o),L(ge.$$.fragment,o),L(_e.$$.fragment,o),L(K.$$.fragment,o),L(be.$$.fragment,o),L(ye.$$.fragment,o),L(Le.$$.fragment,o),L(te.$$.fragment,o),L(Oe.$$.fragment,o),L($e.$$.fragment,o),L(Me.$$.fragment,o),L(ae.$$.fragment,o),L(se.$$.fragment,o),L(Ce.$$.fragment,o),L(ze.$$.fragment,o),L(Pe.$$.fragment,o),L(ie.$$.fragment,o),Ao=!1},d(o){t(d),o&&t(v),o&&t(c),O(p),o&&t(Mo),o&&t(A),O(pe),o&&t(Co),o&&t(Y),o&&t(zo),o&&t(We),o&&t(Eo),o&&t(P),o&&t(Fo),o&&t(N),O(ge),o&&t(xo),o&&t(E),O(_e),O(K),o&&t(Po),o&&t(j),O(be),o&&t(So),o&&t(M),O(ye),O(Le),O(te),o&&t(Io),o&&t(G),O(Oe),o&&t(qo),o&&t(Z),O($e),O(Me),O(ae),O(se),o&&t(Wo),o&&t(R),O(Ce),o&&t(Jo),o&&t($),O(ze),O(Pe),O(ie)}}}const ja={local:"openllama",sections:[{local:"overview",title:"Overview"},{local:"transformers.OpenLlamaConfig",title:"OpenLlamaConfig"},{local:"transformers.OpenLlamaModel",title:"OpenLlamaModel"},{local:"transformers.OpenLlamaForCausalLM",title:"OpenLlamaForCausalLM"},{local:"transformers.OpenLlamaForSequenceClassification",title:"OpenLlamaForSequenceClassification"}],title:"Open-Llama"};function Ba(x){return qa(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class Ya extends xa{constructor(d){super();Pa(this,d,Ba,Va,Sa,{})}}export{Ya as default,ja as metadata};
