import{s as Qp,o as Jp,n as Ep}from"../chunks/scheduler.bdbef820.js";import{S as Up,i as Rp,g as d,s as n,r as u,A as Xp,h as i,f as t,c as s,j as _,u as l,x as f,k as g,y as r,a,v as c,d as p,t as h,w as m}from"../chunks/index.33f81d56.js";import{T as Vp}from"../chunks/Tip.34194030.js";import{D as T}from"../chunks/Docstring.64554317.js";import{C as Hp}from"../chunks/CodeBlock.362b34a4.js";import{H as b,E as Zp}from"../chunks/EditOnGithub.a9246e21.js";function Gp(Un){let x,j=`<code>output_hidden_states=True</code>를 전달할 때 <code>outputs.hidden_states[-1]</code>가 <code>outputs.last_hidden_state</code>와 정확히 일치할 것으로 예상할 수 있습니다.
하지만 항상 그런 것은 아닙니다. 일부 모델은 마지막 은닉 상태가 반환될 때 정규화를 적용하거나 다른 후속 프로세스를 적용합니다.`;return{c(){x=d("p"),x.innerHTML=j},l(v){x=i(v,"P",{"data-svelte-h":!0}),f(x)!=="svelte-1jiex4u"&&(x.innerHTML=j)},m(v,Ae){a(v,x,Ae)},p:Ep,d(v){v&&t(x)}}}function Yp(Un){let x,j=`You can’t unpack a <code>ModelOutput</code> directly. Use the <a href="/docs/transformers/main/ko/main_classes/output#transformers.utils.ModelOutput.to_tuple">to_tuple()</a> method to convert it to a tuple
before.`;return{c(){x=d("p"),x.innerHTML=j},l(v){x=i(v,"P",{"data-svelte-h":!0}),f(x)!=="svelte-a313cm"&&(x.innerHTML=j)},m(v,Ae){a(v,x,Ae)},p:Ep,d(v){v&&t(x)}}}function Kp(Un){let x,j,v,Ae,Ye,Pa,Ke,uc=`모든 모델에는 <a href="/docs/transformers/main/ko/main_classes/output#transformers.utils.ModelOutput">ModelOutput</a>의 서브클래스의 인스턴스인 모델 출력이 있습니다. 이들은
모델에서 반환되는 모든 정보를 포함하는 데이터 구조이지만 튜플이나 딕셔너리로도 사용할 수 있습니다.`,La,et,lc="예제를 통해 살펴보겠습니다:",Ba,tt,Wa,ot,cc=`<code>outputs</code> 객체는 <a href="/docs/transformers/main/ko/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput">SequenceClassifierOutput</a>입니다.
아래 해당 클래스의 문서에서 볼 수 있듯이, <code>loss</code>(선택적), <code>logits</code>, <code>hidden_states</code>(선택적) 및 <code>attentions</code>(선택적) 항목이 있습니다. 여기에서는 <code>labels</code>를 전달했기 때문에 <code>loss</code>가 있지만 <code>hidden_states</code>와 <code>attentions</code>가 없는데, 이는 <code>output_hidden_states=True</code> 또는 <code>output_attentions=True</code>를 전달하지 않았기 때문입니다.`,ja,ke,Da,nt,pc="일반적으로 사용할 때와 동일하게 각 속성들에 접근할 수 있으며, 모델이 해당 속성을 반환하지 않은 경우 <code>None</code>이 반환됩니다. 예시에서는 <code>outputs.loss</code>는 모델에서 계산한 손실이고 <code>outputs.attentions</code>는 <code>None</code>입니다.",Ia,st,hc=`<code>outputs</code> 객체를 튜플로 간주할 때는 <code>None</code> 값이 없는 속성만 고려합니다.
예시에서는 <code>loss</code>와 <code>logits</code>라는 두 개의 요소가 있습니다. 그러므로,`,Va,at,Ha,rt,mc="는 <code>(outputs.loss, outputs.logits)</code> 튜플을 반환합니다.",Ea,dt,fc=`<code>outputs</code> 객체를 딕셔너리로 간주할 때는 <code>None</code> 값이 없는 속성만 고려합니다.
예시에는 <code>loss</code>와 <code>logits</code>라는 두 개의 키가 있습니다.`,Qa,it,_c="여기서부터는 두 가지 이상의 모델 유형에서 사용되는 일반 모델 출력을 다룹니다. 구체적인 출력 유형은 해당 모델 페이지에 문서화되어 있습니다.",Ja,ut,Ua,$,lt,vu,Rn,gc=`Base class for all model outputs as dataclass. Has a <code>__getitem__</code> that allows indexing by integer or slice (like a
tuple) or strings (like a dictionary) that will ignore the <code>None</code> attributes. Otherwise behaves like a regular
python dictionary.`,$u,Pe,qu,Le,ct,Ou,Xn,Tc="Convert self to a tuple containing all the attributes/keys that are not <code>None</code>.",Ra,pt,Xa,D,ht,wu,Zn,bc="Base class for model’s outputs, with potential hidden states and attentions.",Za,mt,Ga,I,ft,yu,Gn,xc="Base class for model’s outputs that also contains a pooling of the last hidden states.",Ya,_t,Ka,V,gt,Su,Yn,vc="Base class for model’s outputs, with potential hidden states and attentions.",er,Tt,tr,H,bt,Mu,Kn,$c="Base class for model’s outputs that also contains a pooling of the last hidden states.",or,xt,nr,E,vt,Fu,es,qc="Base class for model’s outputs that may also contain a past key/values (to speed up sequential decoding).",sr,$t,ar,Q,qt,Cu,ts,Oc="Base class for model’s outputs that may also contain a past key/values (to speed up sequential decoding).",rr,Ot,dr,J,wt,zu,os,wc=`Base class for model encoder’s outputs that also contains : pre-computed hidden states that can speed up sequential
decoding.`,ir,yt,ur,U,St,Nu,ns,yc="Base class for causal language model (or autoregressive) outputs.",lr,Mt,cr,R,Ft,Au,ss,Sc="Base class for causal language model (or autoregressive) outputs.",pr,Ct,hr,X,zt,ku,as,Mc="Base class for causal language model (or autoregressive) outputs.",mr,Nt,fr,Z,At,Pu,rs,Fc="Base class for masked language models outputs.",_r,kt,gr,G,Pt,Lu,ds,Cc="Base class for sequence-to-sequence language models outputs.",Tr,Lt,br,Y,Bt,Bu,is,zc="Base class for outputs of models predicting if two sentences are consecutive or not.",xr,Wt,vr,K,jt,Wu,us,Nc="Base class for outputs of sentence classification models.",$r,Dt,qr,ee,It,ju,ls,Ac="Base class for outputs of sequence-to-sequence sentence classification models.",Or,Vt,wr,te,Ht,Du,cs,kc="Base class for outputs of multiple choice models.",yr,Et,Sr,oe,Qt,Iu,ps,Pc="Base class for outputs of token classification models.",Mr,Jt,Fr,ne,Ut,Vu,hs,Lc="Base class for outputs of question answering models.",Cr,Rt,zr,se,Xt,Hu,ms,Bc="Base class for outputs of sequence-to-sequence question answering models.",Nr,Zt,Ar,ae,Gt,Eu,fs,Wc="Base class for sequence-to-sequence spectrogram outputs.",kr,Yt,Pr,re,Kt,Qu,_s,jc="Base class for outputs of semantic segmentation models.",Lr,eo,Br,de,to,Ju,gs,Dc="Base class for outputs of image classification models.",Wr,oo,jr,ie,no,Uu,Ts,Ic="Base class for outputs of image classification models.",Dr,so,Ir,ue,ao,Ru,bs,Vc="Base class for outputs of depth estimation models.",Vr,ro,Hr,le,io,Xu,xs,Hc="Base class for models that have been trained with the Wav2Vec2 loss objective.",Er,uo,Qr,ce,lo,Zu,vs,Ec="Output type of <code>Wav2Vec2ForXVector</code>.",Jr,co,Ur,pe,po,Gu,$s,Qc=`Base class for time series model’s encoder outputs that also contains pre-computed hidden states that can speed up
sequential decoding.`,Rr,ho,Xr,he,mo,Yu,qs,Jc=`Base class for time series model’s decoder outputs that also contain the loss as well as the parameters of the
chosen distribution.`,Zr,fo,Gr,me,_o,Ku,Os,Uc=`Base class for time series model’s predictions outputs that contains the sampled values from the chosen
distribution.`,Yr,go,Kr,fe,To,el,ws,Rc="Base class for model’s outputs, with potential hidden states and attentions.",ed,bo,td,_e,xo,tl,ys,Xc="Base class for model’s outputs that also contains a pooling of the last hidden states.",od,vo,nd,ge,$o,ol,Ss,Zc="Base class for model’s outputs that also contains a pooling of the last hidden states.",sd,qo,ad,Te,Oo,nl,Ms,Gc="Base class for model’s outputs that may also contain a past key/values (to speed up sequential decoding).",rd,wo,dd,be,yo,sl,Fs,Yc="Base class for model’s outputs that may also contain a past key/values (to speed up sequential decoding).",id,So,ud,xe,Mo,al,Cs,Kc=`Base class for model encoder’s outputs that also contains : pre-computed hidden states that can speed up sequential
decoding.`,ld,Fo,cd,ve,Co,rl,zs,ep="Base class for causal language model (or autoregressive) outputs.",pd,zo,hd,$e,No,dl,Ns,tp="Base class for causal language model (or autoregressive) outputs.",md,Ao,fd,qe,ko,il,As,op="Base class for causal language model (or autoregressive) outputs.",_d,Po,gd,Oe,Lo,ul,ks,np="Base class for masked language models outputs.",Td,Bo,bd,we,Wo,ll,Ps,sp="Base class for sequence-to-sequence language models outputs.",xd,jo,vd,ye,Do,cl,Ls,ap="Base class for outputs of models predicting if two sentences are consecutive or not.",$d,Io,qd,Se,Vo,pl,Bs,rp="Base class for outputs of sentence classification models.",Od,Ho,wd,Me,Eo,hl,Ws,dp="Base class for outputs of sequence-to-sequence sentence classification models.",yd,Qo,Sd,Fe,Jo,ml,js,ip="Base class for outputs of multiple choice models.",Md,Uo,Fd,Ce,Ro,fl,Ds,up="Base class for outputs of token classification models.",Cd,Xo,zd,ze,Zo,_l,Is,lp="Base class for outputs of question answering models.",Nd,Go,Ad,Ne,Yo,gl,Vs,cp="Base class for outputs of sequence-to-sequence question answering models.",kd,Ko,Pd,q,en,Tl,Hs,pp="Base class for model’s outputs, with potential hidden states and attentions.",bl,Be,tn,xl,Es,hp="“Returns a new object replacing the specified fields with new values.",Ld,on,Bd,O,nn,vl,Qs,mp="Base class for model’s outputs, with potential hidden states and attentions.",$l,We,sn,ql,Js,fp="“Returns a new object replacing the specified fields with new values.",Wd,an,jd,w,rn,Ol,Us,_p="Base class for model’s outputs that also contains a pooling of the last hidden states.",wl,je,dn,yl,Rs,gp="“Returns a new object replacing the specified fields with new values.",Dd,un,Id,y,ln,Sl,Xs,Tp="Base class for model’s outputs that may also contain a past key/values (to speed up sequential decoding).",Ml,De,cn,Fl,Zs,bp="“Returns a new object replacing the specified fields with new values.",Vd,pn,Hd,S,hn,Cl,Gs,xp=`Base class for model encoder’s outputs that also contains : pre-computed hidden states that can speed up sequential
decoding.`,zl,Ie,mn,Nl,Ys,vp="“Returns a new object replacing the specified fields with new values.",Ed,fn,Qd,M,_n,Al,Ks,$p="Base class for causal language model (or autoregressive) outputs.",kl,Ve,gn,Pl,ea,qp="“Returns a new object replacing the specified fields with new values.",Jd,Tn,Ud,F,bn,Ll,ta,Op="Base class for masked language models outputs.",Bl,He,xn,Wl,oa,wp="“Returns a new object replacing the specified fields with new values.",Rd,vn,Xd,C,$n,jl,na,yp="Base class for sequence-to-sequence language models outputs.",Dl,Ee,qn,Il,sa,Sp="“Returns a new object replacing the specified fields with new values.",Zd,On,Gd,z,wn,Vl,aa,Mp="Base class for outputs of models predicting if two sentences are consecutive or not.",Hl,Qe,yn,El,ra,Fp="“Returns a new object replacing the specified fields with new values.",Yd,Sn,Kd,N,Mn,Ql,da,Cp="Base class for outputs of sentence classification models.",Jl,Je,Fn,Ul,ia,zp="“Returns a new object replacing the specified fields with new values.",ei,Cn,ti,A,zn,Rl,ua,Np="Base class for outputs of sequence-to-sequence sentence classification models.",Xl,Ue,Nn,Zl,la,Ap="“Returns a new object replacing the specified fields with new values.",oi,An,ni,k,kn,Gl,ca,kp="Base class for outputs of multiple choice models.",Yl,Re,Pn,Kl,pa,Pp="“Returns a new object replacing the specified fields with new values.",si,Ln,ai,P,Bn,ec,ha,Lp="Base class for outputs of token classification models.",tc,Xe,Wn,oc,ma,Bp="“Returns a new object replacing the specified fields with new values.",ri,jn,di,L,Dn,nc,fa,Wp="Base class for outputs of question answering models.",sc,Ze,In,ac,_a,jp="“Returns a new object replacing the specified fields with new values.",ii,Vn,ui,B,Hn,rc,ga,Dp="Base class for outputs of sequence-to-sequence question answering models.",dc,Ge,En,ic,Ta,Ip="“Returns a new object replacing the specified fields with new values.",li,Qn,ci,ka,pi;return Ye=new b({props:{title:"모델 출력",local:"model-outputs",headingTag:"h1"}}),tt=new Hp({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEJlcnRUb2tlbml6ZXIlMkMlMjBCZXJ0Rm9yU2VxdWVuY2VDbGFzc2lmaWNhdGlvbiUwQWltcG9ydCUyMHRvcmNoJTBBJTBBdG9rZW5pemVyJTIwJTNEJTIwQmVydFRva2VuaXplci5mcm9tX3ByZXRyYWluZWQoJTIyZ29vZ2xlLWJlcnQlMkZiZXJ0LWJhc2UtdW5jYXNlZCUyMiklMEFtb2RlbCUyMCUzRCUyMEJlcnRGb3JTZXF1ZW5jZUNsYXNzaWZpY2F0aW9uLmZyb21fcHJldHJhaW5lZCglMjJnb29nbGUtYmVydCUyRmJlcnQtYmFzZS11bmNhc2VkJTIyKSUwQSUwQWlucHV0cyUyMCUzRCUyMHRva2VuaXplciglMjJIZWxsbyUyQyUyMG15JTIwZG9nJTIwaXMlMjBjdXRlJTIyJTJDJTIwcmV0dXJuX3RlbnNvcnMlM0QlMjJwdCUyMiklMEFsYWJlbHMlMjAlM0QlMjB0b3JjaC50ZW5zb3IoJTVCMSU1RCkudW5zcXVlZXplKDApJTIwJTIwJTIzJTIwJUVCJUIwJUIwJUVDJUI5JTk4JTIwJUVEJTgxJUFDJUVBJUI4JUIwJTIwMSUwQW91dHB1dHMlMjAlM0QlMjBtb2RlbCgqKmlucHV0cyUyQyUyMGxhYmVscyUzRGxhYmVscyk=",highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> BertTokenizer, BertForSequenceClassification
<span class="hljs-keyword">import</span> torch

tokenizer = BertTokenizer.from_pretrained(<span class="hljs-string">&quot;google-bert/bert-base-uncased&quot;</span>)
model = BertForSequenceClassification.from_pretrained(<span class="hljs-string">&quot;google-bert/bert-base-uncased&quot;</span>)

inputs = tokenizer(<span class="hljs-string">&quot;Hello, my dog is cute&quot;</span>, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>)
labels = torch.tensor([<span class="hljs-number">1</span>]).unsqueeze(<span class="hljs-number">0</span>)  <span class="hljs-comment"># 배치 크기 1</span>
outputs = model(**inputs, labels=labels)`,wrap:!1}}),ke=new Vp({props:{$$slots:{default:[Gp]},$$scope:{ctx:Un}}}),at=new Hp({props:{code:"b3V0cHV0cyU1QiUzQTIlNUQ=",highlighted:'outputs[:<span class="hljs-number">2</span>]',wrap:!1}}),ut=new b({props:{title:"ModelOutput",local:"transformers.utils.ModelOutput ][ transformers.utils.ModelOutput",headingTag:"h2"}}),lt=new T({props:{name:"class transformers.utils.ModelOutput",anchor:"transformers.utils.ModelOutput",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/utils/generic.py#L310"}}),Pe=new Vp({props:{warning:!0,$$slots:{default:[Yp]},$$scope:{ctx:Un}}}),ct=new T({props:{name:"to_tuple",anchor:"transformers.utils.ModelOutput.to_tuple",parameters:[],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/utils/generic.py#L454"}}),pt=new b({props:{title:"BaseModelOutput",local:"transformers.BaseModelOutput ][ transformers.modeling_outputs.BaseModelOutput",headingTag:"h2"}}),ht=new T({props:{name:"class transformers.modeling_outputs.BaseModelOutput",anchor:"transformers.modeling_outputs.BaseModelOutput",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutput.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutput.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutput.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L24"}}),mt=new b({props:{title:"BaseModelOutputWithPooling",local:"transformers.modeling_outputs.BaseModelOutputWithPooling ][ transformers.modeling_outputs.BaseModelOutputWithPooling",headingTag:"h2"}}),ft=new T({props:{name:"class transformers.modeling_outputs.BaseModelOutputWithPooling",anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"pooler_output",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling.pooler_output",description:`<strong>pooler_output</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, hidden_size)</code>) &#x2014;
Last layer hidden-state of the first token of the sequence (classification token) after further processing
through the layers used for the auxiliary pretraining task. E.g. for BERT-family of models, this returns
the classification token after processing through a linear layer and a tanh activation function. The linear
layer weights are trained from the next sentence prediction (classification) objective during pretraining.`,name:"pooler_output"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L69"}}),_t=new b({props:{title:"BaseModelOutputWithCrossAttentions",local:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions ][ transformers.modeling_outputs.BaseModelOutputWithCrossAttentions",headingTag:"h2"}}),gt=new T({props:{name:"class transformers.modeling_outputs.BaseModelOutputWithCrossAttentions",anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> and <code>config.add_cross_attention=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
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 of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L162"}}),Tt=new b({props:{title:"BaseModelOutputWithPoolingAndCrossAttentions",local:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions ][ transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions",headingTag:"h2"}}),bt=new T({props:{name:"class transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions",anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"pooler_output",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"past_key_values",val:": Optional = None"},{name:"attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.pooler_output",description:`<strong>pooler_output</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, hidden_size)</code>) &#x2014;
Last layer hidden-state of the first token of the sequence (classification token) after further processing
through the layers used for the auxiliary pretraining task. E.g. for BERT-family of models, this returns
the classification token after processing through a linear layer and a tanh activation function. The linear
layer weights are trained from the next sentence prediction (classification) objective during pretraining.`,name:"pooler_output"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> and <code>config.add_cross_attention=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
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 of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.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 optionally if
<code>config.is_encoder_decoder=True</code> 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 optionally if
<code>config.is_encoder_decoder=True</code> in the cross-attention blocks) that can be used (see <code>past_key_values</code>
input) to speed up sequential decoding.`,name:"past_key_values"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L195"}}),xt=new b({props:{title:"BaseModelOutputWithPast",local:"transformers.modeling_outputs.BaseModelOutputWithPast ][ transformers.modeling_outputs.BaseModelOutputWithPast",headingTag:"h2"}}),vt=new T({props:{name:"class transformers.modeling_outputs.BaseModelOutputWithPast",anchor:"transformers.modeling_outputs.BaseModelOutputWithPast",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"past_key_values",val:": Optional = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithPast.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPast.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 optionally if
<code>config.is_encoder_decoder=True</code> 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 optionally if
<code>config.is_encoder_decoder=True</code> in the cross-attention blocks) that can be used (see <code>past_key_values</code>
input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPast.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPast.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L123"}}),$t=new b({props:{title:"BaseModelOutputWithPastAndCrossAttentions",local:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions ][ transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions",headingTag:"h2"}}),qt=new T({props:{name:"class transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions",anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"past_key_values",val:": Optional = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.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 optionally if
<code>config.is_encoder_decoder=True</code> 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 optionally if
<code>config.is_encoder_decoder=True</code> in the cross-attention blocks) that can be used (see <code>past_key_values</code>
input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> and <code>config.add_cross_attention=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
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 of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L244"}}),Ot=new b({props:{title:"Seq2SeqModelOutput",local:"transformers.modeling_outputs.Seq2SeqModelOutput ][ transformers.modeling_outputs.Seq2SeqModelOutput",headingTag:"h2"}}),wt=new T({props:{name:"class transformers.modeling_outputs.Seq2SeqModelOutput",anchor:"transformers.modeling_outputs.Seq2SeqModelOutput",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"past_key_values",val:": Optional = None"},{name:"decoder_hidden_states",val:": Optional = None"},{name:"decoder_attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"},{name:"encoder_last_hidden_state",val:": Optional = None"},{name:"encoder_hidden_states",val:": Optional = None"},{name:"encoder_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the decoder of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.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.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.decoder_hidden_states",description:`<strong>decoder_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>) &#x2014;
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 decoder at the output of each layer plus the optional initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.decoder_attentions",description:`<strong>decoder_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>) &#x2014;
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 of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.cross_attentions",description:`<strong>cross_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>) &#x2014;
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 of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.encoder_hidden_states",description:`<strong>encoder_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>) &#x2014;
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 encoder at the output of each layer plus the optional initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.encoder_attentions",description:`<strong>encoder_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>) &#x2014;
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 of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L515"}}),yt=new b({props:{title:"CausalLMOutput",local:"transformers.modeling_outputs.CausalLMOutput ][ transformers.modeling_outputs.CausalLMOutput",headingTag:"h2"}}),St=new T({props:{name:"class transformers.modeling_outputs.CausalLMOutput",anchor:"transformers.modeling_outputs.CausalLMOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.CausalLMOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss (for next-token prediction).`,name:"loss"},{anchor:"transformers.modeling_outputs.CausalLMOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.CausalLMOutput.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.CausalLMOutput.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L648"}}),Mt=new b({props:{title:"CausalLMOutputWithCrossAttentions",local:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions ][ transformers.modeling_outputs.CausalLMOutputWithCrossAttentions",headingTag:"h2"}}),Ft=new T({props:{name:"class transformers.modeling_outputs.CausalLMOutputWithCrossAttentions",anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"past_key_values",val:": Optional = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss (for next-token prediction).`,name:"loss"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.cross_attentions",description:`<strong>cross_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>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Cross attentions weights after the attention softmax, used to compute the weighted average in the
cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.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>torch.FloatTensor</code> tuples of length <code>config.n_layers</code>, with each tuple containing the cached key,
value states of the self-attention and the cross-attention layers if model is used in encoder-decoder
setting. Only relevant if <code>config.is_decoder = True</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the attention blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L713"}}),Ct=new b({props:{title:"CausalLMOutputWithPast",local:"transformers.modeling_outputs.CausalLMOutputWithPast ][ transformers.modeling_outputs.CausalLMOutputWithPast",headingTag:"h2"}}),zt=new T({props:{name:"class transformers.modeling_outputs.CausalLMOutputWithPast",anchor:"transformers.modeling_outputs.CausalLMOutputWithPast",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"past_key_values",val:": Optional = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss (for next-token prediction).`,name:"loss"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.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>)</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.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L677"}}),Nt=new b({props:{title:"MaskedLMOutput",local:"transformers.modeling_outputs.MaskedLMOutput ][ transformers.modeling_outputs.MaskedLMOutput",headingTag:"h2"}}),At=new T({props:{name:"class transformers.modeling_outputs.MaskedLMOutput",anchor:"transformers.modeling_outputs.MaskedLMOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.MaskedLMOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Masked language modeling (MLM) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.MaskedLMOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.MaskedLMOutput.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.MaskedLMOutput.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L793"}}),kt=new b({props:{title:"Seq2SeqLMOutput",local:"transformers.modeling_outputs.Seq2SeqLMOutput ][ transformers.modeling_outputs.Seq2SeqLMOutput",headingTag:"h2"}}),Pt=new T({props:{name:"class transformers.modeling_outputs.Seq2SeqLMOutput",anchor:"transformers.modeling_outputs.Seq2SeqLMOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"past_key_values",val:": Optional = None"},{name:"decoder_hidden_states",val:": Optional = None"},{name:"decoder_attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"},{name:"encoder_last_hidden_state",val:": Optional = None"},{name:"encoder_hidden_states",val:": Optional = None"},{name:"encoder_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.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.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.decoder_hidden_states",description:`<strong>decoder_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>) &#x2014;
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 decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.decoder_attentions",description:`<strong>decoder_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>) &#x2014;
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 of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.cross_attentions",description:`<strong>cross_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>) &#x2014;
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 of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.encoder_hidden_states",description:`<strong>encoder_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>) &#x2014;
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 encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.encoder_attentions",description:`<strong>encoder_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>) &#x2014;
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 of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L822"}}),Lt=new b({props:{title:"NextSentencePredictorOutput",local:"transformers.modeling_outputs.NextSentencePredictorOutput ][ transformers.modeling_outputs.NextSentencePredictorOutput",headingTag:"h2"}}),Bt=new T({props:{name:"class transformers.modeling_outputs.NextSentencePredictorOutput",anchor:"transformers.modeling_outputs.NextSentencePredictorOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.NextSentencePredictorOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>next_sentence_label</code> is provided) &#x2014;
Next sequence prediction (classification) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.NextSentencePredictorOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, 2)</code>) &#x2014;
Prediction scores of the next sequence prediction (classification) head (scores of True/False continuation
before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.NextSentencePredictorOutput.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.NextSentencePredictorOutput.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L957"}}),Wt=new b({props:{title:"SequenceClassifierOutput",local:"transformers.modeling_outputs.SequenceClassifierOutput ][ transformers.modeling_outputs.SequenceClassifierOutput",headingTag:"h2"}}),jt=new T({props:{name:"class transformers.modeling_outputs.SequenceClassifierOutput",anchor:"transformers.modeling_outputs.SequenceClassifierOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.SequenceClassifierOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.SequenceClassifierOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.num_labels)</code>) &#x2014;
Classification (or regression if config.num_labels==1) scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.SequenceClassifierOutput.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.SequenceClassifierOutput.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L987"}}),Dt=new b({props:{title:"Seq2SeqSequenceClassifierOutput",local:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput ][ transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput",headingTag:"h2"}}),It=new T({props:{name:"class transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput",anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"past_key_values",val:": Optional = None"},{name:"decoder_hidden_states",val:": Optional = None"},{name:"decoder_attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"},{name:"encoder_last_hidden_state",val:": Optional = None"},{name:"encoder_hidden_states",val:": Optional = None"},{name:"encoder_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>label</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.num_labels)</code>) &#x2014;
Classification (or regression if config.num_labels==1) scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.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.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.decoder_hidden_states",description:`<strong>decoder_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>) &#x2014;
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 decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.decoder_attentions",description:`<strong>decoder_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>) &#x2014;
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 of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.cross_attentions",description:`<strong>cross_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>) &#x2014;
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 of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.encoder_hidden_states",description:`<strong>encoder_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>) &#x2014;
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 encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.encoder_attentions",description:`<strong>encoder_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>) &#x2014;
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 of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1016"}}),Vt=new b({props:{title:"MultipleChoiceModelOutput",local:"transformers.modeling_outputs.MultipleChoiceModelOutput ][ transformers.modeling_outputs.MultipleChoiceModelOutput",headingTag:"h2"}}),Ht=new T({props:{name:"class transformers.modeling_outputs.MultipleChoiceModelOutput",anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <em>(1,)</em>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_choices)</code>) &#x2014;
<em>num_choices</em> is the second dimension of the input tensors. (see <em>input_ids</em> above).</p>
<p>Classification scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1076"}}),Et=new b({props:{title:"TokenClassifierOutput",local:"transformers.modeling_outputs.TokenClassifierOutput ][ transformers.modeling_outputs.TokenClassifierOutput",headingTag:"h2"}}),Qt=new T({props:{name:"class transformers.modeling_outputs.TokenClassifierOutput",anchor:"transformers.modeling_outputs.TokenClassifierOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.TokenClassifierOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided)  &#x2014;
Classification loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.TokenClassifierOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.num_labels)</code>) &#x2014;
Classification scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.TokenClassifierOutput.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.TokenClassifierOutput.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1107"}}),Jt=new b({props:{title:"QuestionAnsweringModelOutput",local:"transformers.modeling_outputs.QuestionAnsweringModelOutput ][ transformers.modeling_outputs.QuestionAnsweringModelOutput",headingTag:"h2"}}),Ut=new T({props:{name:"class transformers.modeling_outputs.QuestionAnsweringModelOutput",anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"start_logits",val:": FloatTensor = None"},{name:"end_logits",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Total span extraction loss is the sum of a Cross-Entropy for the start and end positions.`,name:"loss"},{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.start_logits",description:`<strong>start_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-start scores (before SoftMax).`,name:"start_logits"},{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.end_logits",description:`<strong>end_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-end scores (before SoftMax).`,name:"end_logits"},{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.hidden_states",description:`<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>) &#x2014;
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.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1136"}}),Rt=new b({props:{title:"Seq2SeqQuestionAnsweringModelOutput",local:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput ][ transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput",headingTag:"h2"}}),Xt=new T({props:{name:"class transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput",anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"start_logits",val:": FloatTensor = None"},{name:"end_logits",val:": FloatTensor = None"},{name:"past_key_values",val:": Optional = None"},{name:"decoder_hidden_states",val:": Optional = None"},{name:"decoder_attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"},{name:"encoder_last_hidden_state",val:": Optional = None"},{name:"encoder_hidden_states",val:": Optional = None"},{name:"encoder_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Total span extraction loss is the sum of a Cross-Entropy for the start and end positions.`,name:"loss"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.start_logits",description:`<strong>start_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-start scores (before SoftMax).`,name:"start_logits"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.end_logits",description:`<strong>end_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-end scores (before SoftMax).`,name:"end_logits"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.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.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.decoder_hidden_states",description:`<strong>decoder_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>) &#x2014;
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 decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.decoder_attentions",description:`<strong>decoder_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>) &#x2014;
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 of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.cross_attentions",description:`<strong>cross_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>) &#x2014;
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 of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.encoder_hidden_states",description:`<strong>encoder_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>) &#x2014;
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 encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.encoder_attentions",description:`<strong>encoder_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>) &#x2014;
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 of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1168"}}),Zt=new b({props:{title:"Seq2SeqSpectrogramOutput",local:"transformers.modeling_outputs.Seq2SeqSpectrogramOutput ][ transformers.modeling_outputs.Seq2SeqSpectrogramOutput",headingTag:"h2"}}),Gt=new T({props:{name:"class transformers.modeling_outputs.Seq2SeqSpectrogramOutput",anchor:"transformers.modeling_outputs.Seq2SeqSpectrogramOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"spectrogram",val:": FloatTensor = None"},{name:"past_key_values",val:": Optional = None"},{name:"decoder_hidden_states",val:": Optional = None"},{name:"decoder_attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"},{name:"encoder_last_hidden_state",val:": Optional = None"},{name:"encoder_hidden_states",val:": Optional = None"},{name:"encoder_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqSpectrogramOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Spectrogram generation loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.Seq2SeqSpectrogramOutput.spectrogram",description:`<strong>spectrogram</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, num_bins)</code>) &#x2014;
The predicted spectrogram.`,name:"spectrogram"},{anchor:"transformers.modeling_outputs.Seq2SeqSpectrogramOutput.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.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqSpectrogramOutput.decoder_hidden_states",description:`<strong>decoder_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>) &#x2014;
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 decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqSpectrogramOutput.decoder_attentions",description:`<strong>decoder_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>) &#x2014;
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 of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqSpectrogramOutput.cross_attentions",description:`<strong>cross_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>) &#x2014;
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 of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqSpectrogramOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqSpectrogramOutput.encoder_hidden_states",description:`<strong>encoder_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>) &#x2014;
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 encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqSpectrogramOutput.encoder_attentions",description:`<strong>encoder_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>) &#x2014;
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 of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1501"}}),Yt=new b({props:{title:"SemanticSegmenterOutput",local:"transformers.modeling_outputs.SemanticSegmenterOutput ][ transformers.modeling_outputs.SemanticSegmenterOutput",headingTag:"h2"}}),Kt=new T({props:{name:"class transformers.modeling_outputs.SemanticSegmenterOutput",anchor:"transformers.modeling_outputs.SemanticSegmenterOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.SemanticSegmenterOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.SemanticSegmenterOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.num_labels, logits_height, logits_width)</code>) &#x2014;
Classification scores for each pixel.</p>
<div class="course-tip course-tip-orange bg-gradient-to-br dark:bg-gradient-to-r before:border-orange-500 dark:before:border-orange-800 from-orange-50 dark:from-gray-900 to-white dark:to-gray-950 border border-orange-50 text-orange-700 dark:text-gray-400">
						
<p>The logits returned do not necessarily have the same size as the <code>pixel_values</code> passed as inputs. This is
to avoid doing two interpolations and lose some quality when a user needs to resize the logits to the
original image size as post-processing. You should always check your logits shape and resize as needed.</p>

					</div>`,name:"logits"},{anchor:"transformers.modeling_outputs.SemanticSegmenterOutput.hidden_states",description:`<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>) &#x2014;
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, patch_size, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.SemanticSegmenterOutput.attentions",description:`<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>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, patch_size, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1231"}}),eo=new b({props:{title:"ImageClassifierOutput",local:"transformers.modeling_outputs.ImageClassifierOutput ][ transformers.modeling_outputs.ImageClassifierOutput",headingTag:"h2"}}),to=new T({props:{name:"class transformers.modeling_outputs.ImageClassifierOutput",anchor:"transformers.modeling_outputs.ImageClassifierOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.ImageClassifierOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.ImageClassifierOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.num_labels)</code>) &#x2014;
Classification (or regression if config.num_labels==1) scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.ImageClassifierOutput.hidden_states",description:`<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>) &#x2014;
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 stage) of shape <code>(batch_size, sequence_length, hidden_size)</code>. Hidden-states
(also called feature maps) of the model at the output of each stage.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.ImageClassifierOutput.attentions",description:`<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>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, patch_size, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1269"}}),oo=new b({props:{title:"ImageClassifierOutputWithNoAttention",local:"transformers.modeling_outputs.ImageClassifierOutputWithNoAttention ][ transformers.modeling_outputs.ImageClassifierOutputWithNoAttention",headingTag:"h2"}}),no=new T({props:{name:"class transformers.modeling_outputs.ImageClassifierOutputWithNoAttention",anchor:"transformers.modeling_outputs.ImageClassifierOutputWithNoAttention",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.ImageClassifierOutputWithNoAttention.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.ImageClassifierOutputWithNoAttention.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.num_labels)</code>) &#x2014;
Classification (or regression if config.num_labels==1) scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.ImageClassifierOutputWithNoAttention.hidden_states",description:`<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>) &#x2014;
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 stage) of shape <code>(batch_size, num_channels, height, width)</code>. Hidden-states (also
called feature maps) of the model at the output of each stage.`,name:"hidden_states"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1297"}}),so=new b({props:{title:"DepthEstimatorOutput",local:"transformers.modeling_outputs.DepthEstimatorOutput ][ transformers.modeling_outputs.DepthEstimatorOutput",headingTag:"h2"}}),ao=new T({props:{name:"class transformers.modeling_outputs.DepthEstimatorOutput",anchor:"transformers.modeling_outputs.DepthEstimatorOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"predicted_depth",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.DepthEstimatorOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.DepthEstimatorOutput.predicted_depth",description:`<strong>predicted_depth</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, height, width)</code>) &#x2014;
Predicted depth for each pixel.`,name:"predicted_depth"},{anchor:"transformers.modeling_outputs.DepthEstimatorOutput.hidden_states",description:`<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>) &#x2014;
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, num_channels, height, width)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.DepthEstimatorOutput.attentions",description:`<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>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, patch_size, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1318"}}),ro=new b({props:{title:"Wav2Vec2BaseModelOutput",local:"transformers.modeling_outputs.Wav2Vec2BaseModelOutput ][ transformers.modeling_outputs.Wav2Vec2BaseModelOutput",headingTag:"h2"}}),io=new T({props:{name:"class transformers.modeling_outputs.Wav2Vec2BaseModelOutput",anchor:"transformers.modeling_outputs.Wav2Vec2BaseModelOutput",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"extract_features",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Wav2Vec2BaseModelOutput.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.Wav2Vec2BaseModelOutput.extract_features",description:`<strong>extract_features</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, conv_dim[-1])</code>) &#x2014;
Sequence of extracted feature vectors of the last convolutional layer of the model.`,name:"extract_features"},{anchor:"transformers.modeling_outputs.Wav2Vec2BaseModelOutput.hidden_states",description:`<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>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.Wav2Vec2BaseModelOutput.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1376"}}),uo=new b({props:{title:"XVectorOutput",local:"transformers.modeling_outputs.XVectorOutput ][ transformers.modeling_outputs.XVectorOutput",headingTag:"h2"}}),lo=new T({props:{name:"class transformers.modeling_outputs.XVectorOutput",anchor:"transformers.modeling_outputs.XVectorOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"logits",val:": FloatTensor = None"},{name:"embeddings",val:": FloatTensor = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.XVectorOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.XVectorOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.xvector_output_dim)</code>) &#x2014;
Classification hidden states before AMSoftmax.`,name:"logits"},{anchor:"transformers.modeling_outputs.XVectorOutput.embeddings",description:`<strong>embeddings</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.xvector_output_dim)</code>) &#x2014;
Utterance embeddings used for vector similarity-based retrieval.`,name:"embeddings"},{anchor:"transformers.modeling_outputs.XVectorOutput.hidden_states",description:`<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>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.XVectorOutput.attentions",description:`<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>) &#x2014;
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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1405"}}),co=new b({props:{title:"Seq2SeqTSModelOutput",local:"transformers.modeling_outputs.Seq2SeqTSModelOutput ][ transformers.modeling_outputs.Seq2SeqTSModelOutput",headingTag:"h2"}}),po=new T({props:{name:"class transformers.modeling_outputs.Seq2SeqTSModelOutput",anchor:"transformers.modeling_outputs.Seq2SeqTSModelOutput",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"past_key_values",val:": Optional = None"},{name:"decoder_hidden_states",val:": Optional = None"},{name:"decoder_attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"},{name:"encoder_last_hidden_state",val:": Optional = None"},{name:"encoder_hidden_states",val:": Optional = None"},{name:"encoder_attentions",val:": Optional = None"},{name:"loc",val:": Optional = None"},{name:"scale",val:": Optional = None"},{name:"static_features",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqTSModelOutput.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the decoder of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqTSModelOutput.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.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqTSModelOutput.decoder_hidden_states",description:`<strong>decoder_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>) &#x2014;
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 decoder at the output of each layer plus the optional initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqTSModelOutput.decoder_attentions",description:`<strong>decoder_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>) &#x2014;
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 of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqTSModelOutput.cross_attentions",description:`<strong>cross_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>) &#x2014;
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 of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqTSModelOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqTSModelOutput.encoder_hidden_states",description:`<strong>encoder_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>) &#x2014;
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 encoder at the output of each layer plus the optional initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqTSModelOutput.encoder_attentions",description:`<strong>encoder_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>) &#x2014;
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 of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqTSModelOutput.loc",description:`<strong>loc</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size,)</code> or <code>(batch_size, input_size)</code>, <em>optional</em>) &#x2014;
Shift values of each time series&#x2019; context window which is used to give the model inputs of the same
magnitude and then used to shift back to the original magnitude.`,name:"loc"},{anchor:"transformers.modeling_outputs.Seq2SeqTSModelOutput.scale",description:`<strong>scale</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size,)</code> or <code>(batch_size, input_size)</code>, <em>optional</em>) &#x2014;
Scaling values of each time series&#x2019; context window which is used to give the model inputs of the same
magnitude and then used to rescale back to the original magnitude.`,name:"scale"},{anchor:"transformers.modeling_outputs.Seq2SeqTSModelOutput.static_features",description:`<strong>static_features</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, feature size)</code>, <em>optional</em>) &#x2014;
Static features of each time series&#x2019; in a batch which are copied to the covariates at inference time.`,name:"static_features"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1561"}}),ho=new b({props:{title:"Seq2SeqTSPredictionOutput",local:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput ][ transformers.modeling_outputs.Seq2SeqTSPredictionOutput",headingTag:"h2"}}),mo=new T({props:{name:"class transformers.modeling_outputs.Seq2SeqTSPredictionOutput",anchor:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput",parameters:[{name:"loss",val:": Optional = None"},{name:"params",val:": Optional = None"},{name:"past_key_values",val:": Optional = None"},{name:"decoder_hidden_states",val:": Optional = None"},{name:"decoder_attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"},{name:"encoder_last_hidden_state",val:": Optional = None"},{name:"encoder_hidden_states",val:": Optional = None"},{name:"encoder_attentions",val:": Optional = None"},{name:"loc",val:": Optional = None"},{name:"scale",val:": Optional = None"},{name:"static_features",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when a <code>future_values</code> is provided) &#x2014;
Distributional loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput.params",description:`<strong>params</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_samples, num_params)</code>) &#x2014;
Parameters of the chosen distribution.`,name:"params"},{anchor:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput.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.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput.decoder_hidden_states",description:`<strong>decoder_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>) &#x2014;
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 decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput.decoder_attentions",description:`<strong>decoder_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>) &#x2014;
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 of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput.cross_attentions",description:`<strong>cross_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>) &#x2014;
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 of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput.encoder_hidden_states",description:`<strong>encoder_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>) &#x2014;
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 encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput.encoder_attentions",description:`<strong>encoder_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>) &#x2014;
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 of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput.loc",description:`<strong>loc</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size,)</code> or <code>(batch_size, input_size)</code>, <em>optional</em>) &#x2014;
Shift values of each time series&#x2019; context window which is used to give the model inputs of the same
magnitude and then used to shift back to the original magnitude.`,name:"loc"},{anchor:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput.scale",description:`<strong>scale</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size,)</code> or <code>(batch_size, input_size)</code>, <em>optional</em>) &#x2014;
Scaling values of each time series&#x2019; context window which is used to give the model inputs of the same
magnitude and then used to rescale back to the original magnitude.`,name:"scale"},{anchor:"transformers.modeling_outputs.Seq2SeqTSPredictionOutput.static_features",description:`<strong>static_features</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, feature size)</code>, <em>optional</em>) &#x2014;
Static features of each time series&#x2019; in a batch which are copied to the covariates at inference time.`,name:"static_features"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1633"}}),fo=new b({props:{title:"SampleTSPredictionOutput",local:"transformers.modeling_outputs.SampleTSPredictionOutput ][ transformers.modeling_outputs.SampleTSPredictionOutput",headingTag:"h2"}}),_o=new T({props:{name:"class transformers.modeling_outputs.SampleTSPredictionOutput",anchor:"transformers.modeling_outputs.SampleTSPredictionOutput",parameters:[{name:"sequences",val:": FloatTensor = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.SampleTSPredictionOutput.sequences",description:`<strong>sequences</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_samples, prediction_length)</code> or <code>(batch_size, num_samples, prediction_length, input_size)</code>) &#x2014;
Sampled values from the chosen distribution.`,name:"sequences"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1705"}}),go=new b({props:{title:"TFBaseModelOutput",local:"transformers.modeling_outputs.TFBaseModelOutput ][ transformers.modeling_tf_outputs.TFBaseModelOutput",headingTag:"h2"}}),To=new T({props:{name:"class transformers.modeling_tf_outputs.TFBaseModelOutput",anchor:"transformers.modeling_tf_outputs.TFBaseModelOutput",parameters:[{name:"last_hidden_state",val:": tf.Tensor = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutput.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L26"}}),bo=new b({props:{title:"TFBaseModelOutputWithPooling",local:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling ][ transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling",headingTag:"h2"}}),xo=new T({props:{name:"class transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling",anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling",parameters:[{name:"last_hidden_state",val:": tf.Tensor = None"},{name:"pooler_output",val:": tf.Tensor = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling.pooler_output",description:`<strong>pooler_output</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, hidden_size)</code>) &#x2014;
Last layer hidden-state of the first token of the sequence (classification token) further processed by a
Linear layer and a Tanh activation function. The Linear layer weights are trained from the next sentence
prediction (classification) objective during pretraining.</p>
<p>This output is usually <em>not</em> a good summary of the semantic content of the input, you&#x2019;re often better with
averaging or pooling the sequence of hidden-states for the whole input sequence.`,name:"pooler_output"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L71"}}),vo=new b({props:{title:"TFBaseModelOutputWithPoolingAndCrossAttentions",local:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions ][ transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions",headingTag:"h2"}}),$o=new T({props:{name:"class transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions",anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions",parameters:[{name:"last_hidden_state",val:": tf.Tensor = None"},{name:"pooler_output",val:": tf.Tensor = None"},{name:"past_key_values",val:": List[tf.Tensor] | None = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"},{name:"cross_attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions.pooler_output",description:`<strong>pooler_output</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, hidden_size)</code>) &#x2014;
Last layer hidden-state of the first token of the sequence (classification token) further processed by a
Linear layer and a Tanh activation function. The Linear layer weights are trained from the next sentence
prediction (classification) objective during pretraining.</p>
<p>This output is usually <em>not</em> a good summary of the semantic content of the input, you&#x2019;re often better with
averaging or pooling the sequence of hidden-states for the whole input sequence.`,name:"pooler_output"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions.past_key_values",description:`<strong>past_key_values</strong> (<code>List[tf.Tensor]</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
List of <code>tf.Tensor</code> of length <code>config.n_layers</code>, with each tensor of shape <code>(2, batch_size, num_heads, sequence_length, embed_size_per_head)</code>).</p>
<p>Contains pre-computed hidden-states (key and values in the attention blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L127"}}),qo=new b({props:{title:"TFBaseModelOutputWithPast",local:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPast ][ transformers.modeling_tf_outputs.TFBaseModelOutputWithPast",headingTag:"h2"}}),Oo=new T({props:{name:"class transformers.modeling_tf_outputs.TFBaseModelOutputWithPast",anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPast",parameters:[{name:"last_hidden_state",val:": tf.Tensor = None"},{name:"past_key_values",val:": List[tf.Tensor] | None = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPast.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPast.past_key_values",description:`<strong>past_key_values</strong> (<code>List[tf.Tensor]</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
List of <code>tf.Tensor</code> of length <code>config.n_layers</code>, with each tensor of shape <code>(2, batch_size, num_heads, sequence_length, embed_size_per_head)</code>).</p>
<p>Contains pre-computed hidden-states (key and values in the attention blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPast.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPast.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L175"}}),wo=new b({props:{title:"TFBaseModelOutputWithPastAndCrossAttentions",local:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions ][ transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions",headingTag:"h2"}}),yo=new T({props:{name:"class transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions",anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions",parameters:[{name:"last_hidden_state",val:": tf.Tensor = None"},{name:"past_key_values",val:": List[tf.Tensor] | None = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"},{name:"cross_attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions.past_key_values",description:`<strong>past_key_values</strong> (<code>List[tf.Tensor]</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
List of <code>tf.Tensor</code> of length <code>config.n_layers</code>, with each tensor of shape <code>(2, batch_size, num_heads, sequence_length, embed_size_per_head)</code>).</p>
<p>Contains pre-computed hidden-states (key and values in the attention blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"},{anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L244"}}),So=new b({props:{title:"TFSeq2SeqModelOutput",local:"transformers.modeling_tf_outputs.TFSeq2SeqModelOutput ][ transformers.modeling_tf_outputs.TFSeq2SeqModelOutput",headingTag:"h2"}}),Mo=new T({props:{name:"class transformers.modeling_tf_outputs.TFSeq2SeqModelOutput",anchor:"transformers.modeling_tf_outputs.TFSeq2SeqModelOutput",parameters:[{name:"last_hidden_state",val:": tf.Tensor = None"},{name:"past_key_values",val:": List[tf.Tensor] | None = None"},{name:"decoder_hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"decoder_attentions",val:": Tuple[tf.Tensor] | None = None"},{name:"cross_attentions",val:": Tuple[tf.Tensor] | None = None"},{name:"encoder_last_hidden_state",val:": tf.Tensor | None = None"},{name:"encoder_hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"encoder_attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqModelOutput.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the decoder of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqModelOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>List[tf.Tensor]</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
List of <code>tf.Tensor</code> of length <code>config.n_layers</code>, with each tensor of shape <code>(2, batch_size, num_heads, sequence_length, embed_size_per_head)</code>).</p>
<p>Contains pre-computed hidden-states (key and values in the attention blocks) of the decoder that can be
used (see <code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqModelOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqModelOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqModelOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqModelOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqModelOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqModelOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L287"}}),Fo=new b({props:{title:"TFCausalLMOutput",local:"transformers.modeling_tf_outputs.TFCausalLMOutput ][ transformers.modeling_tf_outputs.TFCausalLMOutput",headingTag:"h2"}}),Co=new T({props:{name:"class transformers.modeling_tf_outputs.TFCausalLMOutput",anchor:"transformers.modeling_tf_outputs.TFCausalLMOutput",parameters:[{name:"loss",val:": tf.Tensor | None = None"},{name:"logits",val:": tf.Tensor = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutput.loss",description:`<strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(n,)</code>, <em>optional</em>, where n is the number of non-masked labels, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss (for next-token prediction).`,name:"loss"},{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutput.logits",description:`<strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L347"}}),zo=new b({props:{title:"TFCausalLMOutputWithCrossAttentions",local:"transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions ][ transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions",headingTag:"h2"}}),No=new T({props:{name:"class transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions",anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions",parameters:[{name:"loss",val:": tf.Tensor | None = None"},{name:"logits",val:": tf.Tensor = None"},{name:"past_key_values",val:": List[tf.Tensor] | None = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"},{name:"cross_attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions.loss",description:`<strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(n,)</code>, <em>optional</em>, where n is the number of non-masked labels, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss (for next-token prediction).`,name:"loss"},{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions.logits",description:`<strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"},{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions.past_key_values",description:`<strong>past_key_values</strong> (<code>List[tf.Tensor]</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
List of <code>tf.Tensor</code> of length <code>config.n_layers</code>, with each tensor of shape <code>(2, batch_size, num_heads, sequence_length, embed_size_per_head)</code>).</p>
<p>Contains pre-computed hidden-states (key and values in the attention blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L412"}}),Ao=new b({props:{title:"TFCausalLMOutputWithPast",local:"transformers.modeling_tf_outputs.TFCausalLMOutputWithPast ][ transformers.modeling_tf_outputs.TFCausalLMOutputWithPast",headingTag:"h2"}}),ko=new T({props:{name:"class transformers.modeling_tf_outputs.TFCausalLMOutputWithPast",anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithPast",parameters:[{name:"loss",val:": tf.Tensor | None = None"},{name:"logits",val:": tf.Tensor = None"},{name:"past_key_values",val:": List[tf.Tensor] | None = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithPast.loss",description:`<strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(n,)</code>, <em>optional</em>, where n is the number of non-masked labels, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss (for next-token prediction).`,name:"loss"},{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithPast.logits",description:`<strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithPast.past_key_values",description:`<strong>past_key_values</strong> (<code>List[tf.Tensor]</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
List of <code>tf.Tensor</code> of length <code>config.n_layers</code>, with each tensor of shape <code>(2, batch_size, num_heads, sequence_length, embed_size_per_head)</code>).</p>
<p>Contains pre-computed hidden-states (key and values in the attention blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithPast.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithPast.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L376"}}),Po=new b({props:{title:"TFMaskedLMOutput",local:"transformers.modeling_tf_outputs.TFMaskedLMOutput ][ transformers.modeling_tf_outputs.TFMaskedLMOutput",headingTag:"h2"}}),Lo=new T({props:{name:"class transformers.modeling_tf_outputs.TFMaskedLMOutput",anchor:"transformers.modeling_tf_outputs.TFMaskedLMOutput",parameters:[{name:"loss",val:": tf.Tensor | None = None"},{name:"logits",val:": tf.Tensor = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFMaskedLMOutput.loss",description:`<strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(n,)</code>, <em>optional</em>, where n is the number of non-masked labels, returned when <code>labels</code> is provided) &#x2014;
Masked language modeling (MLM) loss.`,name:"loss"},{anchor:"transformers.modeling_tf_outputs.TFMaskedLMOutput.logits",description:`<strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_tf_outputs.TFMaskedLMOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFMaskedLMOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L455"}}),Bo=new b({props:{title:"TFSeq2SeqLMOutput",local:"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput ][ transformers.modeling_tf_outputs.TFSeq2SeqLMOutput",headingTag:"h2"}}),Wo=new T({props:{name:"class transformers.modeling_tf_outputs.TFSeq2SeqLMOutput",anchor:"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput",parameters:[{name:"loss",val:": tf.Tensor | None = None"},{name:"logits",val:": tf.Tensor = None"},{name:"past_key_values",val:": List[tf.Tensor] | None = None"},{name:"decoder_hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"decoder_attentions",val:": Tuple[tf.Tensor] | None = None"},{name:"cross_attentions",val:": Tuple[tf.Tensor] | None = None"},{name:"encoder_last_hidden_state",val:": tf.Tensor | None = None"},{name:"encoder_hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"encoder_attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput.loss",description:`<strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(n,)</code>, <em>optional</em>, where n is the number of non-masked labels, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss.`,name:"loss"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput.logits",description:`<strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>List[tf.Tensor]</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
List of <code>tf.Tensor</code> of length <code>config.n_layers</code>, with each tensor of shape <code>(2, batch_size, num_heads, sequence_length, embed_size_per_head)</code>).</p>
<p>Contains pre-computed hidden-states (key and values in the attention blocks) of the decoder that can be
used (see <code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L484"}}),jo=new b({props:{title:"TFNextSentencePredictorOutput",local:"transformers.modeling_tf_outputs.TFNextSentencePredictorOutput ][ transformers.modeling_tf_outputs.TFNextSentencePredictorOutput",headingTag:"h2"}}),Do=new T({props:{name:"class transformers.modeling_tf_outputs.TFNextSentencePredictorOutput",anchor:"transformers.modeling_tf_outputs.TFNextSentencePredictorOutput",parameters:[{name:"loss",val:": tf.Tensor | None = None"},{name:"logits",val:": tf.Tensor = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFNextSentencePredictorOutput.loss",description:`<strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(n,)</code>, <em>optional</em>, where n is the number of non-masked labels, returned when <code>next_sentence_label</code> is provided) &#x2014;
Next sentence prediction loss.`,name:"loss"},{anchor:"transformers.modeling_tf_outputs.TFNextSentencePredictorOutput.logits",description:`<strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, 2)</code>) &#x2014;
Prediction scores of the next sequence prediction (classification) head (scores of True/False continuation
before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_tf_outputs.TFNextSentencePredictorOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFNextSentencePredictorOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L543"}}),Io=new b({props:{title:"TFSequenceClassifierOutput",local:"transformers.modeling_tf_outputs.TFSequenceClassifierOutput ][ transformers.modeling_tf_outputs.TFSequenceClassifierOutput",headingTag:"h2"}}),Vo=new T({props:{name:"class transformers.modeling_tf_outputs.TFSequenceClassifierOutput",anchor:"transformers.modeling_tf_outputs.TFSequenceClassifierOutput",parameters:[{name:"loss",val:": tf.Tensor | None = None"},{name:"logits",val:": tf.Tensor = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFSequenceClassifierOutput.loss",description:`<strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, )</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_tf_outputs.TFSequenceClassifierOutput.logits",description:`<strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, config.num_labels)</code>) &#x2014;
Classification (or regression if config.num_labels==1) scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_tf_outputs.TFSequenceClassifierOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFSequenceClassifierOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L573"}}),Ho=new b({props:{title:"TFSeq2SeqSequenceClassifierOutput",local:"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput ][ transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput",headingTag:"h2"}}),Eo=new T({props:{name:"class transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput",anchor:"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput",parameters:[{name:"loss",val:": tf.Tensor | None = None"},{name:"logits",val:": tf.Tensor = None"},{name:"past_key_values",val:": List[tf.Tensor] | None = None"},{name:"decoder_hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"decoder_attentions",val:": Tuple[tf.Tensor] | None = None"},{name:"cross_attentions",val:": Tuple[tf.Tensor] | None = None"},{name:"encoder_last_hidden_state",val:": tf.Tensor | None = None"},{name:"encoder_hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"encoder_attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput.loss",description:`<strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>label</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput.logits",description:`<strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, config.num_labels)</code>) &#x2014;
Classification (or regression if config.num_labels==1) scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>List[tf.Tensor]</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
List of <code>tf.Tensor</code> of length <code>config.n_layers</code>, with each tensor of shape <code>(2, batch_size, num_heads, sequence_length, embed_size_per_head)</code>).</p>
<p>Contains pre-computed hidden-states (key and values in the attention blocks) of the decoder that can be
used (see <code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>`,name:"cross_attentions"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L602"}}),Qo=new b({props:{title:"TFMultipleChoiceModelOutput",local:"transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput ][ transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput",headingTag:"h2"}}),Jo=new T({props:{name:"class transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput",anchor:"transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput",parameters:[{name:"loss",val:": tf.Tensor | None = None"},{name:"logits",val:": tf.Tensor = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput.loss",description:`<strong>loss</strong> (<code>tf.Tensor</code> of shape <em>(batch_size, )</em>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification loss.`,name:"loss"},{anchor:"transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput.logits",description:`<strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, num_choices)</code>) &#x2014;
<em>num_choices</em> is the second dimension of the input tensors. (see <em>input_ids</em> above).</p>
<p>Classification scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L753"}}),Uo=new b({props:{title:"TFTokenClassifierOutput",local:"transformers.modeling_tf_outputs.TFTokenClassifierOutput ][ transformers.modeling_tf_outputs.TFTokenClassifierOutput",headingTag:"h2"}}),Ro=new T({props:{name:"class transformers.modeling_tf_outputs.TFTokenClassifierOutput",anchor:"transformers.modeling_tf_outputs.TFTokenClassifierOutput",parameters:[{name:"loss",val:": tf.Tensor | None = None"},{name:"logits",val:": tf.Tensor = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFTokenClassifierOutput.loss",description:`<strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(n,)</code>, <em>optional</em>, where n is the number of unmasked labels, returned when <code>labels</code> is provided)  &#x2014;
Classification loss.`,name:"loss"},{anchor:"transformers.modeling_tf_outputs.TFTokenClassifierOutput.logits",description:`<strong>logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, config.num_labels)</code>) &#x2014;
Classification scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_tf_outputs.TFTokenClassifierOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFTokenClassifierOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L784"}}),Xo=new b({props:{title:"TFQuestionAnsweringModelOutput",local:"transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput ][ transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput",headingTag:"h2"}}),Zo=new T({props:{name:"class transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput",anchor:"transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput",parameters:[{name:"loss",val:": tf.Tensor | None = None"},{name:"start_logits",val:": tf.Tensor = None"},{name:"end_logits",val:": tf.Tensor = None"},{name:"hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput.loss",description:`<strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, )</code>, <em>optional</em>, returned when <code>start_positions</code> and <code>end_positions</code> are provided) &#x2014;
Total span extraction loss is the sum of a Cross-Entropy for the start and end positions.`,name:"loss"},{anchor:"transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput.start_logits",description:`<strong>start_logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-start scores (before SoftMax).`,name:"start_logits"},{anchor:"transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput.end_logits",description:`<strong>end_logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-end scores (before SoftMax).`,name:"end_logits"},{anchor:"transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L813"}}),Go=new b({props:{title:"TFSeq2SeqQuestionAnsweringModelOutput",local:"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput ][ transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput",headingTag:"h2"}}),Yo=new T({props:{name:"class transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput",anchor:"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput",parameters:[{name:"loss",val:": tf.Tensor | None = None"},{name:"start_logits",val:": tf.Tensor = None"},{name:"end_logits",val:": tf.Tensor = None"},{name:"past_key_values",val:": List[tf.Tensor] | None = None"},{name:"decoder_hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"decoder_attentions",val:": Tuple[tf.Tensor] | None = None"},{name:"encoder_last_hidden_state",val:": tf.Tensor | None = None"},{name:"encoder_hidden_states",val:": Tuple[tf.Tensor] | None = None"},{name:"encoder_attentions",val:": Tuple[tf.Tensor] | None = None"}],parametersDescription:[{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput.loss",description:`<strong>loss</strong> (<code>tf.Tensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Total span extraction loss is the sum of a Cross-Entropy for the start and end positions.`,name:"loss"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput.start_logits",description:`<strong>start_logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-start scores (before SoftMax).`,name:"start_logits"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput.end_logits",description:`<strong>end_logits</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-end scores (before SoftMax).`,name:"end_logits"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>List[tf.Tensor]</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
List of <code>tf.Tensor</code> of length <code>config.n_layers</code>, with each tensor of shape <code>(2, batch_size, num_heads, sequence_length, embed_size_per_head)</code>).</p>
<p>Contains pre-computed hidden-states (key and values in the attention blocks) of the decoder that can be
used (see <code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>tf.Tensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(tf.Tensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>tf.Tensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_tf_outputs.py#L845"}}),Ko=new b({props:{title:"FlaxBaseModelOutput",local:"transformers.modeling_flax_outputs.FlaxBaseModelOutput ][ transformers.modeling_flax_outputs.FlaxBaseModelOutput",headingTag:"h2"}}),en=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxBaseModelOutput",anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutput",parameters:[{name:"last_hidden_state",val:": Array = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutput.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L22"}}),tn=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutput.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),on=new b({props:{title:"FlaxBaseModelOutputWithPast",local:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast ][ transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast",headingTag:"h2"}}),nn=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast",anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast",parameters:[{name:"last_hidden_state",val:": Array = None"},{name:"past_key_values",val:": Optional = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast.past_key_values",description:`<strong>past_key_values</strong> (<code>Dict[str, jnp.ndarray]</code>) &#x2014;
Dictionary of pre-computed hidden-states (key and values in the attention blocks) that can be used for fast
auto-regressive decoding. Pre-computed key and value hidden-states are of shape <em>[batch_size, max_length]</em>.`,name:"past_key_values"},{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast.attentions",description:`<strong>attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L106"}}),sn=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),an=new b({props:{title:"FlaxBaseModelOutputWithPooling",local:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling ][ transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling",headingTag:"h2"}}),rn=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling",anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling",parameters:[{name:"last_hidden_state",val:": Array = None"},{name:"pooler_output",val:": Array = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling.pooler_output",description:`<strong>pooler_output</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, hidden_size)</code>) &#x2014;
Last layer hidden-state of the first token of the sequence (classification token) further processed by a
Linear layer and a Tanh activation function. The Linear layer weights are trained from the next sentence
prediction (classification) objective during pretraining.`,name:"pooler_output"},{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling.attentions",description:`<strong>attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L136"}}),dn=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),un=new b({props:{title:"FlaxBaseModelOutputWithPastAndCrossAttentions",local:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions ][ transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions",headingTag:"h2"}}),ln=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions",anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions",parameters:[{name:"last_hidden_state",val:": Array = None"},{name:"past_key_values",val:": Optional = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(jnp.ndarray))</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(jnp.ndarray)</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 optionally if
<code>config.is_encoder_decoder=True</code> 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 optionally if
<code>config.is_encoder_decoder=True</code> in the cross-attention blocks) that can be used (see <code>past_key_values</code>
input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions.attentions",description:`<strong>attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</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.`,name:"attentions"},{anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> and <code>config.add_cross_attention=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L216"}}),cn=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),pn=new b({props:{title:"FlaxSeq2SeqModelOutput",local:"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput ][ transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput",headingTag:"h2"}}),hn=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput",anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput",parameters:[{name:"last_hidden_state",val:": Array = None"},{name:"past_key_values",val:": Optional = None"},{name:"decoder_hidden_states",val:": Optional = None"},{name:"decoder_attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"},{name:"encoder_last_hidden_state",val:": Optional = None"},{name:"encoder_hidden_states",val:": Optional = None"},{name:"encoder_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the decoder of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(jnp.ndarray))</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(jnp.ndarray)</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.`,name:"past_key_values"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L262"}}),mn=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),fn=new b({props:{title:"FlaxCausalLMOutputWithCrossAttentions",local:"transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions ][ transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions",headingTag:"h2"}}),_n=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions",anchor:"transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions",parameters:[{name:"logits",val:": Array = None"},{name:"past_key_values",val:": Optional = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions.logits",description:`<strong>logits</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions.attentions",description:`<strong>attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</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.`,name:"attentions"},{anchor:"transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Cross attentions weights after the attention softmax, used to compute the weighted average in the
cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(jnp.ndarray))</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>jnp.ndarray</code> tuples of length <code>config.n_layers</code>, with each tuple containing the cached key, value
states of the self-attention and the cross-attention layers if model is used in encoder-decoder setting.
Only relevant if <code>config.is_decoder = True</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the attention blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L323"}}),gn=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),Tn=new b({props:{title:"FlaxMaskedLMOutput",local:"transformers.modeling_flax_outputs.FlaxMaskedLMOutput ][ transformers.modeling_flax_outputs.FlaxMaskedLMOutput",headingTag:"h2"}}),bn=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxMaskedLMOutput",anchor:"transformers.modeling_flax_outputs.FlaxMaskedLMOutput",parameters:[{name:"logits",val:": Array = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxMaskedLMOutput.logits",description:`<strong>logits</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_flax_outputs.FlaxMaskedLMOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxMaskedLMOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L364"}}),xn=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxMaskedLMOutput.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),vn=new b({props:{title:"FlaxSeq2SeqLMOutput",local:"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput ][ transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput",headingTag:"h2"}}),$n=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput",anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput",parameters:[{name:"logits",val:": Array = None"},{name:"past_key_values",val:": Optional = None"},{name:"decoder_hidden_states",val:": Optional = None"},{name:"decoder_attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"},{name:"encoder_last_hidden_state",val:": Optional = None"},{name:"encoder_hidden_states",val:": Optional = None"},{name:"encoder_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput.logits",description:`<strong>logits</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(jnp.ndarray))</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(jnp.ndarray)</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.`,name:"past_key_values"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L393"}}),qn=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),On=new b({props:{title:"FlaxNextSentencePredictorOutput",local:"transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput ][ transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput",headingTag:"h2"}}),wn=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput",anchor:"transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput",parameters:[{name:"logits",val:": Array = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput.logits",description:`<strong>logits</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, 2)</code>) &#x2014;
Prediction scores of the next sequence prediction (classification) head (scores of True/False continuation
before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L450"}}),yn=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),Sn=new b({props:{title:"FlaxSequenceClassifierOutput",local:"transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput ][ transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput",headingTag:"h2"}}),Mn=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput",anchor:"transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput",parameters:[{name:"logits",val:": Array = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput.logits",description:`<strong>logits</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, config.num_labels)</code>) &#x2014;
Classification (or regression if config.num_labels==1) scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L477"}}),Fn=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),Cn=new b({props:{title:"FlaxSeq2SeqSequenceClassifierOutput",local:"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput ][ transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput",headingTag:"h2"}}),zn=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput",anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput",parameters:[{name:"logits",val:": Array = None"},{name:"past_key_values",val:": Optional = None"},{name:"decoder_hidden_states",val:": Optional = None"},{name:"decoder_attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"},{name:"encoder_last_hidden_state",val:": Optional = None"},{name:"encoder_hidden_states",val:": Optional = None"},{name:"encoder_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput.logits",description:`<strong>logits</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, config.num_labels)</code>) &#x2014;
Classification (or regression if config.num_labels==1) scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(jnp.ndarray))</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(jnp.ndarray)</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.`,name:"past_key_values"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L503"}}),Nn=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),An=new b({props:{title:"FlaxMultipleChoiceModelOutput",local:"transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput ][ transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput",headingTag:"h2"}}),kn=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput",anchor:"transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput",parameters:[{name:"logits",val:": Array = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput.logits",description:`<strong>logits</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, num_choices)</code>) &#x2014;
<em>num_choices</em> is the second dimension of the input tensors. (see <em>input_ids</em> above).</p>
<p>Classification scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L560"}}),Pn=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),Ln=new b({props:{title:"FlaxTokenClassifierOutput",local:"transformers.modeling_flax_outputs.FlaxTokenClassifierOutput ][ transformers.modeling_flax_outputs.FlaxTokenClassifierOutput",headingTag:"h2"}}),Bn=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxTokenClassifierOutput",anchor:"transformers.modeling_flax_outputs.FlaxTokenClassifierOutput",parameters:[{name:"logits",val:": Array = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxTokenClassifierOutput.logits",description:`<strong>logits</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length, config.num_labels)</code>) &#x2014;
Classification scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_flax_outputs.FlaxTokenClassifierOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxTokenClassifierOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L588"}}),Wn=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxTokenClassifierOutput.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),jn=new b({props:{title:"FlaxQuestionAnsweringModelOutput",local:"transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput ][ transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput",headingTag:"h2"}}),Dn=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput",anchor:"transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput",parameters:[{name:"start_logits",val:": Array = None"},{name:"end_logits",val:": Array = None"},{name:"hidden_states",val:": Optional = None"},{name:"attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput.start_logits",description:`<strong>start_logits</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-start scores (before SoftMax).`,name:"start_logits"},{anchor:"transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput.end_logits",description:`<strong>end_logits</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-end scores (before SoftMax).`,name:"end_logits"},{anchor:"transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + 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 initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</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.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L614"}}),In=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),Vn=new b({props:{title:"FlaxSeq2SeqQuestionAnsweringModelOutput",local:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput ][ transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput",headingTag:"h2"}}),Hn=new T({props:{name:"class transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput",anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput",parameters:[{name:"start_logits",val:": Array = None"},{name:"end_logits",val:": Array = None"},{name:"past_key_values",val:": Optional = None"},{name:"decoder_hidden_states",val:": Optional = None"},{name:"decoder_attentions",val:": Optional = None"},{name:"cross_attentions",val:": Optional = None"},{name:"encoder_last_hidden_state",val:": Optional = None"},{name:"encoder_hidden_states",val:": Optional = None"},{name:"encoder_attentions",val:": Optional = None"}],parametersDescription:[{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput.start_logits",description:`<strong>start_logits</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-start scores (before SoftMax).`,name:"start_logits"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput.end_logits",description:`<strong>end_logits</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-end scores (before SoftMax).`,name:"end_logits"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(jnp.ndarray))</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(jnp.ndarray)</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.`,name:"past_key_values"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>jnp.ndarray</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for the output of the embeddings + one for the output of each layer) of shape
<code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(jnp.ndarray)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>jnp.ndarray</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_flax_outputs.py#L643"}}),En=new T({props:{name:"replace",anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput.replace",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/main/src/flax/struct.py#L111"}}),Qn=new Zp({props:{source:"https://github.com/huggingface/transformers/blob/main/docs/source/ko/main_classes/output.md"}}),{c(){x=d("meta"),j=n(),v=d("p"),Ae=n(),u(Ye.$$.fragment),Pa=n(),Ke=d("p"),Ke.innerHTML=uc,La=n(),et=d("p"),et.textContent=lc,Ba=n(),u(tt.$$.fragment),Wa=n(),ot=d("p"),ot.innerHTML=cc,ja=n(),u(ke.$$.fragment),Da=n(),nt=d("p"),nt.innerHTML=pc,Ia=n(),st=d("p"),st.innerHTML=hc,Va=n(),u(at.$$.fragment),Ha=n(),rt=d("p"),rt.innerHTML=mc,Ea=n(),dt=d("p"),dt.innerHTML=fc,Qa=n(),it=d("p"),it.textContent=_c,Ja=n(),u(ut.$$.fragment),Ua=n(),$=d("div"),u(lt.$$.fragment),vu=n(),Rn=d("p"),Rn.innerHTML=gc,$u=n(),u(Pe.$$.fragment),qu=n(),Le=d("div"),u(ct.$$.fragment),Ou=n(),Xn=d("p"),Xn.innerHTML=Tc,Ra=n(),u(pt.$$.fragment),Xa=n(),D=d("div"),u(ht.$$.fragment),wu=n(),Zn=d("p"),Zn.textContent=bc,Za=n(),u(mt.$$.fragment),Ga=n(),I=d("div"),u(ft.$$.fragment),yu=n(),Gn=d("p"),Gn.textContent=xc,Ya=n(),u(_t.$$.fragment),Ka=n(),V=d("div"),u(gt.$$.fragment),Su=n(),Yn=d("p"),Yn.textContent=vc,er=n(),u(Tt.$$.fragment),tr=n(),H=d("div"),u(bt.$$.fragment),Mu=n(),Kn=d("p"),Kn.textContent=$c,or=n(),u(xt.$$.fragment),nr=n(),E=d("div"),u(vt.$$.fragment),Fu=n(),es=d("p"),es.textContent=qc,sr=n(),u($t.$$.fragment),ar=n(),Q=d("div"),u(qt.$$.fragment),Cu=n(),ts=d("p"),ts.textContent=Oc,rr=n(),u(Ot.$$.fragment),dr=n(),J=d("div"),u(wt.$$.fragment),zu=n(),os=d("p"),os.textContent=wc,ir=n(),u(yt.$$.fragment),ur=n(),U=d("div"),u(St.$$.fragment),Nu=n(),ns=d("p"),ns.textContent=yc,lr=n(),u(Mt.$$.fragment),cr=n(),R=d("div"),u(Ft.$$.fragment),Au=n(),ss=d("p"),ss.textContent=Sc,pr=n(),u(Ct.$$.fragment),hr=n(),X=d("div"),u(zt.$$.fragment),ku=n(),as=d("p"),as.textContent=Mc,mr=n(),u(Nt.$$.fragment),fr=n(),Z=d("div"),u(At.$$.fragment),Pu=n(),rs=d("p"),rs.textContent=Fc,_r=n(),u(kt.$$.fragment),gr=n(),G=d("div"),u(Pt.$$.fragment),Lu=n(),ds=d("p"),ds.textContent=Cc,Tr=n(),u(Lt.$$.fragment),br=n(),Y=d("div"),u(Bt.$$.fragment),Bu=n(),is=d("p"),is.textContent=zc,xr=n(),u(Wt.$$.fragment),vr=n(),K=d("div"),u(jt.$$.fragment),Wu=n(),us=d("p"),us.textContent=Nc,$r=n(),u(Dt.$$.fragment),qr=n(),ee=d("div"),u(It.$$.fragment),ju=n(),ls=d("p"),ls.textContent=Ac,Or=n(),u(Vt.$$.fragment),wr=n(),te=d("div"),u(Ht.$$.fragment),Du=n(),cs=d("p"),cs.textContent=kc,yr=n(),u(Et.$$.fragment),Sr=n(),oe=d("div"),u(Qt.$$.fragment),Iu=n(),ps=d("p"),ps.textContent=Pc,Mr=n(),u(Jt.$$.fragment),Fr=n(),ne=d("div"),u(Ut.$$.fragment),Vu=n(),hs=d("p"),hs.textContent=Lc,Cr=n(),u(Rt.$$.fragment),zr=n(),se=d("div"),u(Xt.$$.fragment),Hu=n(),ms=d("p"),ms.textContent=Bc,Nr=n(),u(Zt.$$.fragment),Ar=n(),ae=d("div"),u(Gt.$$.fragment),Eu=n(),fs=d("p"),fs.textContent=Wc,kr=n(),u(Yt.$$.fragment),Pr=n(),re=d("div"),u(Kt.$$.fragment),Qu=n(),_s=d("p"),_s.textContent=jc,Lr=n(),u(eo.$$.fragment),Br=n(),de=d("div"),u(to.$$.fragment),Ju=n(),gs=d("p"),gs.textContent=Dc,Wr=n(),u(oo.$$.fragment),jr=n(),ie=d("div"),u(no.$$.fragment),Uu=n(),Ts=d("p"),Ts.textContent=Ic,Dr=n(),u(so.$$.fragment),Ir=n(),ue=d("div"),u(ao.$$.fragment),Ru=n(),bs=d("p"),bs.textContent=Vc,Vr=n(),u(ro.$$.fragment),Hr=n(),le=d("div"),u(io.$$.fragment),Xu=n(),xs=d("p"),xs.textContent=Hc,Er=n(),u(uo.$$.fragment),Qr=n(),ce=d("div"),u(lo.$$.fragment),Zu=n(),vs=d("p"),vs.innerHTML=Ec,Jr=n(),u(co.$$.fragment),Ur=n(),pe=d("div"),u(po.$$.fragment),Gu=n(),$s=d("p"),$s.textContent=Qc,Rr=n(),u(ho.$$.fragment),Xr=n(),he=d("div"),u(mo.$$.fragment),Yu=n(),qs=d("p"),qs.textContent=Jc,Zr=n(),u(fo.$$.fragment),Gr=n(),me=d("div"),u(_o.$$.fragment),Ku=n(),Os=d("p"),Os.textContent=Uc,Yr=n(),u(go.$$.fragment),Kr=n(),fe=d("div"),u(To.$$.fragment),el=n(),ws=d("p"),ws.textContent=Rc,ed=n(),u(bo.$$.fragment),td=n(),_e=d("div"),u(xo.$$.fragment),tl=n(),ys=d("p"),ys.textContent=Xc,od=n(),u(vo.$$.fragment),nd=n(),ge=d("div"),u($o.$$.fragment),ol=n(),Ss=d("p"),Ss.textContent=Zc,sd=n(),u(qo.$$.fragment),ad=n(),Te=d("div"),u(Oo.$$.fragment),nl=n(),Ms=d("p"),Ms.textContent=Gc,rd=n(),u(wo.$$.fragment),dd=n(),be=d("div"),u(yo.$$.fragment),sl=n(),Fs=d("p"),Fs.textContent=Yc,id=n(),u(So.$$.fragment),ud=n(),xe=d("div"),u(Mo.$$.fragment),al=n(),Cs=d("p"),Cs.textContent=Kc,ld=n(),u(Fo.$$.fragment),cd=n(),ve=d("div"),u(Co.$$.fragment),rl=n(),zs=d("p"),zs.textContent=ep,pd=n(),u(zo.$$.fragment),hd=n(),$e=d("div"),u(No.$$.fragment),dl=n(),Ns=d("p"),Ns.textContent=tp,md=n(),u(Ao.$$.fragment),fd=n(),qe=d("div"),u(ko.$$.fragment),il=n(),As=d("p"),As.textContent=op,_d=n(),u(Po.$$.fragment),gd=n(),Oe=d("div"),u(Lo.$$.fragment),ul=n(),ks=d("p"),ks.textContent=np,Td=n(),u(Bo.$$.fragment),bd=n(),we=d("div"),u(Wo.$$.fragment),ll=n(),Ps=d("p"),Ps.textContent=sp,xd=n(),u(jo.$$.fragment),vd=n(),ye=d("div"),u(Do.$$.fragment),cl=n(),Ls=d("p"),Ls.textContent=ap,$d=n(),u(Io.$$.fragment),qd=n(),Se=d("div"),u(Vo.$$.fragment),pl=n(),Bs=d("p"),Bs.textContent=rp,Od=n(),u(Ho.$$.fragment),wd=n(),Me=d("div"),u(Eo.$$.fragment),hl=n(),Ws=d("p"),Ws.textContent=dp,yd=n(),u(Qo.$$.fragment),Sd=n(),Fe=d("div"),u(Jo.$$.fragment),ml=n(),js=d("p"),js.textContent=ip,Md=n(),u(Uo.$$.fragment),Fd=n(),Ce=d("div"),u(Ro.$$.fragment),fl=n(),Ds=d("p"),Ds.textContent=up,Cd=n(),u(Xo.$$.fragment),zd=n(),ze=d("div"),u(Zo.$$.fragment),_l=n(),Is=d("p"),Is.textContent=lp,Nd=n(),u(Go.$$.fragment),Ad=n(),Ne=d("div"),u(Yo.$$.fragment),gl=n(),Vs=d("p"),Vs.textContent=cp,kd=n(),u(Ko.$$.fragment),Pd=n(),q=d("div"),u(en.$$.fragment),Tl=n(),Hs=d("p"),Hs.textContent=pp,bl=n(),Be=d("div"),u(tn.$$.fragment),xl=n(),Es=d("p"),Es.textContent=hp,Ld=n(),u(on.$$.fragment),Bd=n(),O=d("div"),u(nn.$$.fragment),vl=n(),Qs=d("p"),Qs.textContent=mp,$l=n(),We=d("div"),u(sn.$$.fragment),ql=n(),Js=d("p"),Js.textContent=fp,Wd=n(),u(an.$$.fragment),jd=n(),w=d("div"),u(rn.$$.fragment),Ol=n(),Us=d("p"),Us.textContent=_p,wl=n(),je=d("div"),u(dn.$$.fragment),yl=n(),Rs=d("p"),Rs.textContent=gp,Dd=n(),u(un.$$.fragment),Id=n(),y=d("div"),u(ln.$$.fragment),Sl=n(),Xs=d("p"),Xs.textContent=Tp,Ml=n(),De=d("div"),u(cn.$$.fragment),Fl=n(),Zs=d("p"),Zs.textContent=bp,Vd=n(),u(pn.$$.fragment),Hd=n(),S=d("div"),u(hn.$$.fragment),Cl=n(),Gs=d("p"),Gs.textContent=xp,zl=n(),Ie=d("div"),u(mn.$$.fragment),Nl=n(),Ys=d("p"),Ys.textContent=vp,Ed=n(),u(fn.$$.fragment),Qd=n(),M=d("div"),u(_n.$$.fragment),Al=n(),Ks=d("p"),Ks.textContent=$p,kl=n(),Ve=d("div"),u(gn.$$.fragment),Pl=n(),ea=d("p"),ea.textContent=qp,Jd=n(),u(Tn.$$.fragment),Ud=n(),F=d("div"),u(bn.$$.fragment),Ll=n(),ta=d("p"),ta.textContent=Op,Bl=n(),He=d("div"),u(xn.$$.fragment),Wl=n(),oa=d("p"),oa.textContent=wp,Rd=n(),u(vn.$$.fragment),Xd=n(),C=d("div"),u($n.$$.fragment),jl=n(),na=d("p"),na.textContent=yp,Dl=n(),Ee=d("div"),u(qn.$$.fragment),Il=n(),sa=d("p"),sa.textContent=Sp,Zd=n(),u(On.$$.fragment),Gd=n(),z=d("div"),u(wn.$$.fragment),Vl=n(),aa=d("p"),aa.textContent=Mp,Hl=n(),Qe=d("div"),u(yn.$$.fragment),El=n(),ra=d("p"),ra.textContent=Fp,Yd=n(),u(Sn.$$.fragment),Kd=n(),N=d("div"),u(Mn.$$.fragment),Ql=n(),da=d("p"),da.textContent=Cp,Jl=n(),Je=d("div"),u(Fn.$$.fragment),Ul=n(),ia=d("p"),ia.textContent=zp,ei=n(),u(Cn.$$.fragment),ti=n(),A=d("div"),u(zn.$$.fragment),Rl=n(),ua=d("p"),ua.textContent=Np,Xl=n(),Ue=d("div"),u(Nn.$$.fragment),Zl=n(),la=d("p"),la.textContent=Ap,oi=n(),u(An.$$.fragment),ni=n(),k=d("div"),u(kn.$$.fragment),Gl=n(),ca=d("p"),ca.textContent=kp,Yl=n(),Re=d("div"),u(Pn.$$.fragment),Kl=n(),pa=d("p"),pa.textContent=Pp,si=n(),u(Ln.$$.fragment),ai=n(),P=d("div"),u(Bn.$$.fragment),ec=n(),ha=d("p"),ha.textContent=Lp,tc=n(),Xe=d("div"),u(Wn.$$.fragment),oc=n(),ma=d("p"),ma.textContent=Bp,ri=n(),u(jn.$$.fragment),di=n(),L=d("div"),u(Dn.$$.fragment),nc=n(),fa=d("p"),fa.textContent=Wp,sc=n(),Ze=d("div"),u(In.$$.fragment),ac=n(),_a=d("p"),_a.textContent=jp,ii=n(),u(Vn.$$.fragment),ui=n(),B=d("div"),u(Hn.$$.fragment),rc=n(),ga=d("p"),ga.textContent=Dp,dc=n(),Ge=d("div"),u(En.$$.fragment),ic=n(),Ta=d("p"),Ta.textContent=Ip,li=n(),u(Qn.$$.fragment),ci=n(),ka=d("p"),this.h()},l(e){const o=Xp("svelte-u9bgzb",document.head);x=i(o,"META",{name:!0,content:!0}),o.forEach(t),j=s(e),v=i(e,"P",{}),_(v).forEach(t),Ae=s(e),l(Ye.$$.fragment,e),Pa=s(e),Ke=i(e,"P",{"data-svelte-h":!0}),f(Ke)!=="svelte-12oer72"&&(Ke.innerHTML=uc),La=s(e),et=i(e,"P",{"data-svelte-h":!0}),f(et)!=="svelte-1l6z8e8"&&(et.textContent=lc),Ba=s(e),l(tt.$$.fragment,e),Wa=s(e),ot=i(e,"P",{"data-svelte-h":!0}),f(ot)!=="svelte-1xes8p3"&&(ot.innerHTML=cc),ja=s(e),l(ke.$$.fragment,e),Da=s(e),nt=i(e,"P",{"data-svelte-h":!0}),f(nt)!=="svelte-1ijv72b"&&(nt.innerHTML=pc),Ia=s(e),st=i(e,"P",{"data-svelte-h":!0}),f(st)!=="svelte-1ecdcu0"&&(st.innerHTML=hc),Va=s(e),l(at.$$.fragment,e),Ha=s(e),rt=i(e,"P",{"data-svelte-h":!0}),f(rt)!=="svelte-16t44q2"&&(rt.innerHTML=mc),Ea=s(e),dt=i(e,"P",{"data-svelte-h":!0}),f(dt)!=="svelte-aovql3"&&(dt.innerHTML=fc),Qa=s(e),it=i(e,"P",{"data-svelte-h":!0}),f(it)!=="svelte-1dd03yu"&&(it.textContent=_c),Ja=s(e),l(ut.$$.fragment,e),Ua=s(e),$=i(e,"DIV",{class:!0});var W=_($);l(lt.$$.fragment,W),vu=s(W),Rn=i(W,"P",{"data-svelte-h":!0}),f(Rn)!=="svelte-1q6gwat"&&(Rn.innerHTML=gc),$u=s(W),l(Pe.$$.fragment,W),qu=s(W),Le=i(W,"DIV",{class:!0});var Jn=_(Le);l(ct.$$.fragment,Jn),Ou=s(Jn),Xn=i(Jn,"P",{"data-svelte-h":!0}),f(Xn)!=="svelte-1gdpts"&&(Xn.innerHTML=Tc),Jn.forEach(t),W.forEach(t),Ra=s(e),l(pt.$$.fragment,e),Xa=s(e),D=i(e,"DIV",{class:!0});var hi=_(D);l(ht.$$.fragment,hi),wu=s(hi),Zn=i(hi,"P",{"data-svelte-h":!0}),f(Zn)!=="svelte-19jpj19"&&(Zn.textContent=bc),hi.forEach(t),Za=s(e),l(mt.$$.fragment,e),Ga=s(e),I=i(e,"DIV",{class:!0});var mi=_(I);l(ft.$$.fragment,mi),yu=s(mi),Gn=i(mi,"P",{"data-svelte-h":!0}),f(Gn)!=="svelte-rzpgnp"&&(Gn.textContent=xc),mi.forEach(t),Ya=s(e),l(_t.$$.fragment,e),Ka=s(e),V=i(e,"DIV",{class:!0});var fi=_(V);l(gt.$$.fragment,fi),Su=s(fi),Yn=i(fi,"P",{"data-svelte-h":!0}),f(Yn)!=="svelte-19jpj19"&&(Yn.textContent=vc),fi.forEach(t),er=s(e),l(Tt.$$.fragment,e),tr=s(e),H=i(e,"DIV",{class:!0});var _i=_(H);l(bt.$$.fragment,_i),Mu=s(_i),Kn=i(_i,"P",{"data-svelte-h":!0}),f(Kn)!=="svelte-rzpgnp"&&(Kn.textContent=$c),_i.forEach(t),or=s(e),l(xt.$$.fragment,e),nr=s(e),E=i(e,"DIV",{class:!0});var gi=_(E);l(vt.$$.fragment,gi),Fu=s(gi),es=i(gi,"P",{"data-svelte-h":!0}),f(es)!=="svelte-1kt4x95"&&(es.textContent=qc),gi.forEach(t),sr=s(e),l($t.$$.fragment,e),ar=s(e),Q=i(e,"DIV",{class:!0});var Ti=_(Q);l(qt.$$.fragment,Ti),Cu=s(Ti),ts=i(Ti,"P",{"data-svelte-h":!0}),f(ts)!=="svelte-1kt4x95"&&(ts.textContent=Oc),Ti.forEach(t),rr=s(e),l(Ot.$$.fragment,e),dr=s(e),J=i(e,"DIV",{class:!0});var bi=_(J);l(wt.$$.fragment,bi),zu=s(bi),os=i(bi,"P",{"data-svelte-h":!0}),f(os)!=="svelte-k12cko"&&(os.textContent=wc),bi.forEach(t),ir=s(e),l(yt.$$.fragment,e),ur=s(e),U=i(e,"DIV",{class:!0});var xi=_(U);l(St.$$.fragment,xi),Nu=s(xi),ns=i(xi,"P",{"data-svelte-h":!0}),f(ns)!=="svelte-3npkmq"&&(ns.textContent=yc),xi.forEach(t),lr=s(e),l(Mt.$$.fragment,e),cr=s(e),R=i(e,"DIV",{class:!0});var vi=_(R);l(Ft.$$.fragment,vi),Au=s(vi),ss=i(vi,"P",{"data-svelte-h":!0}),f(ss)!=="svelte-3npkmq"&&(ss.textContent=Sc),vi.forEach(t),pr=s(e),l(Ct.$$.fragment,e),hr=s(e),X=i(e,"DIV",{class:!0});var $i=_(X);l(zt.$$.fragment,$i),ku=s($i),as=i($i,"P",{"data-svelte-h":!0}),f(as)!=="svelte-3npkmq"&&(as.textContent=Mc),$i.forEach(t),mr=s(e),l(Nt.$$.fragment,e),fr=s(e),Z=i(e,"DIV",{class:!0});var qi=_(Z);l(At.$$.fragment,qi),Pu=s(qi),rs=i(qi,"P",{"data-svelte-h":!0}),f(rs)!=="svelte-1xezu93"&&(rs.textContent=Fc),qi.forEach(t),_r=s(e),l(kt.$$.fragment,e),gr=s(e),G=i(e,"DIV",{class:!0});var Oi=_(G);l(Pt.$$.fragment,Oi),Lu=s(Oi),ds=i(Oi,"P",{"data-svelte-h":!0}),f(ds)!=="svelte-1dobm33"&&(ds.textContent=Cc),Oi.forEach(t),Tr=s(e),l(Lt.$$.fragment,e),br=s(e),Y=i(e,"DIV",{class:!0});var wi=_(Y);l(Bt.$$.fragment,wi),Bu=s(wi),is=i(wi,"P",{"data-svelte-h":!0}),f(is)!=="svelte-1bm2i0r"&&(is.textContent=zc),wi.forEach(t),xr=s(e),l(Wt.$$.fragment,e),vr=s(e),K=i(e,"DIV",{class:!0});var yi=_(K);l(jt.$$.fragment,yi),Wu=s(yi),us=i(yi,"P",{"data-svelte-h":!0}),f(us)!=="svelte-o4u80u"&&(us.textContent=Nc),yi.forEach(t),$r=s(e),l(Dt.$$.fragment,e),qr=s(e),ee=i(e,"DIV",{class:!0});var Si=_(ee);l(It.$$.fragment,Si),ju=s(Si),ls=i(Si,"P",{"data-svelte-h":!0}),f(ls)!=="svelte-1kfw2sn"&&(ls.textContent=Ac),Si.forEach(t),Or=s(e),l(Vt.$$.fragment,e),wr=s(e),te=i(e,"DIV",{class:!0});var Mi=_(te);l(Ht.$$.fragment,Mi),Du=s(Mi),cs=i(Mi,"P",{"data-svelte-h":!0}),f(cs)!=="svelte-yql1ve"&&(cs.textContent=kc),Mi.forEach(t),yr=s(e),l(Et.$$.fragment,e),Sr=s(e),oe=i(e,"DIV",{class:!0});var Fi=_(oe);l(Qt.$$.fragment,Fi),Iu=s(Fi),ps=i(Fi,"P",{"data-svelte-h":!0}),f(ps)!=="svelte-1iv9pso"&&(ps.textContent=Pc),Fi.forEach(t),Mr=s(e),l(Jt.$$.fragment,e),Fr=s(e),ne=i(e,"DIV",{class:!0});var Ci=_(ne);l(Ut.$$.fragment,Ci),Vu=s(Ci),hs=i(Ci,"P",{"data-svelte-h":!0}),f(hs)!=="svelte-w7415f"&&(hs.textContent=Lc),Ci.forEach(t),Cr=s(e),l(Rt.$$.fragment,e),zr=s(e),se=i(e,"DIV",{class:!0});var zi=_(se);l(Xt.$$.fragment,zi),Hu=s(zi),ms=i(zi,"P",{"data-svelte-h":!0}),f(ms)!=="svelte-dhzux4"&&(ms.textContent=Bc),zi.forEach(t),Nr=s(e),l(Zt.$$.fragment,e),Ar=s(e),ae=i(e,"DIV",{class:!0});var Ni=_(ae);l(Gt.$$.fragment,Ni),Eu=s(Ni),fs=i(Ni,"P",{"data-svelte-h":!0}),f(fs)!=="svelte-8u8l5m"&&(fs.textContent=Wc),Ni.forEach(t),kr=s(e),l(Yt.$$.fragment,e),Pr=s(e),re=i(e,"DIV",{class:!0});var Ai=_(re);l(Kt.$$.fragment,Ai),Qu=s(Ai),_s=i(Ai,"P",{"data-svelte-h":!0}),f(_s)!=="svelte-kob7ff"&&(_s.textContent=jc),Ai.forEach(t),Lr=s(e),l(eo.$$.fragment,e),Br=s(e),de=i(e,"DIV",{class:!0});var ki=_(de);l(to.$$.fragment,ki),Ju=s(ki),gs=i(ki,"P",{"data-svelte-h":!0}),f(gs)!=="svelte-sv2ymo"&&(gs.textContent=Dc),ki.forEach(t),Wr=s(e),l(oo.$$.fragment,e),jr=s(e),ie=i(e,"DIV",{class:!0});var Pi=_(ie);l(no.$$.fragment,Pi),Uu=s(Pi),Ts=i(Pi,"P",{"data-svelte-h":!0}),f(Ts)!=="svelte-sv2ymo"&&(Ts.textContent=Ic),Pi.forEach(t),Dr=s(e),l(so.$$.fragment,e),Ir=s(e),ue=i(e,"DIV",{class:!0});var Li=_(ue);l(ao.$$.fragment,Li),Ru=s(Li),bs=i(Li,"P",{"data-svelte-h":!0}),f(bs)!=="svelte-1rjgll"&&(bs.textContent=Vc),Li.forEach(t),Vr=s(e),l(ro.$$.fragment,e),Hr=s(e),le=i(e,"DIV",{class:!0});var Bi=_(le);l(io.$$.fragment,Bi),Xu=s(Bi),xs=i(Bi,"P",{"data-svelte-h":!0}),f(xs)!=="svelte-1tmia4b"&&(xs.textContent=Hc),Bi.forEach(t),Er=s(e),l(uo.$$.fragment,e),Qr=s(e),ce=i(e,"DIV",{class:!0});var Wi=_(ce);l(lo.$$.fragment,Wi),Zu=s(Wi),vs=i(Wi,"P",{"data-svelte-h":!0}),f(vs)!=="svelte-srz0v3"&&(vs.innerHTML=Ec),Wi.forEach(t),Jr=s(e),l(co.$$.fragment,e),Ur=s(e),pe=i(e,"DIV",{class:!0});var ji=_(pe);l(po.$$.fragment,ji),Gu=s(ji),$s=i(ji,"P",{"data-svelte-h":!0}),f($s)!=="svelte-dz9ong"&&($s.textContent=Qc),ji.forEach(t),Rr=s(e),l(ho.$$.fragment,e),Xr=s(e),he=i(e,"DIV",{class:!0});var Di=_(he);l(mo.$$.fragment,Di),Yu=s(Di),qs=i(Di,"P",{"data-svelte-h":!0}),f(qs)!=="svelte-os2t7w"&&(qs.textContent=Jc),Di.forEach(t),Zr=s(e),l(fo.$$.fragment,e),Gr=s(e),me=i(e,"DIV",{class:!0});var Ii=_(me);l(_o.$$.fragment,Ii),Ku=s(Ii),Os=i(Ii,"P",{"data-svelte-h":!0}),f(Os)!=="svelte-1iolpnx"&&(Os.textContent=Uc),Ii.forEach(t),Yr=s(e),l(go.$$.fragment,e),Kr=s(e),fe=i(e,"DIV",{class:!0});var Vi=_(fe);l(To.$$.fragment,Vi),el=s(Vi),ws=i(Vi,"P",{"data-svelte-h":!0}),f(ws)!=="svelte-19jpj19"&&(ws.textContent=Rc),Vi.forEach(t),ed=s(e),l(bo.$$.fragment,e),td=s(e),_e=i(e,"DIV",{class:!0});var Hi=_(_e);l(xo.$$.fragment,Hi),tl=s(Hi),ys=i(Hi,"P",{"data-svelte-h":!0}),f(ys)!=="svelte-rzpgnp"&&(ys.textContent=Xc),Hi.forEach(t),od=s(e),l(vo.$$.fragment,e),nd=s(e),ge=i(e,"DIV",{class:!0});var Ei=_(ge);l($o.$$.fragment,Ei),ol=s(Ei),Ss=i(Ei,"P",{"data-svelte-h":!0}),f(Ss)!=="svelte-rzpgnp"&&(Ss.textContent=Zc),Ei.forEach(t),sd=s(e),l(qo.$$.fragment,e),ad=s(e),Te=i(e,"DIV",{class:!0});var Qi=_(Te);l(Oo.$$.fragment,Qi),nl=s(Qi),Ms=i(Qi,"P",{"data-svelte-h":!0}),f(Ms)!=="svelte-1kt4x95"&&(Ms.textContent=Gc),Qi.forEach(t),rd=s(e),l(wo.$$.fragment,e),dd=s(e),be=i(e,"DIV",{class:!0});var Ji=_(be);l(yo.$$.fragment,Ji),sl=s(Ji),Fs=i(Ji,"P",{"data-svelte-h":!0}),f(Fs)!=="svelte-1kt4x95"&&(Fs.textContent=Yc),Ji.forEach(t),id=s(e),l(So.$$.fragment,e),ud=s(e),xe=i(e,"DIV",{class:!0});var Ui=_(xe);l(Mo.$$.fragment,Ui),al=s(Ui),Cs=i(Ui,"P",{"data-svelte-h":!0}),f(Cs)!=="svelte-k12cko"&&(Cs.textContent=Kc),Ui.forEach(t),ld=s(e),l(Fo.$$.fragment,e),cd=s(e),ve=i(e,"DIV",{class:!0});var Ri=_(ve);l(Co.$$.fragment,Ri),rl=s(Ri),zs=i(Ri,"P",{"data-svelte-h":!0}),f(zs)!=="svelte-3npkmq"&&(zs.textContent=ep),Ri.forEach(t),pd=s(e),l(zo.$$.fragment,e),hd=s(e),$e=i(e,"DIV",{class:!0});var Xi=_($e);l(No.$$.fragment,Xi),dl=s(Xi),Ns=i(Xi,"P",{"data-svelte-h":!0}),f(Ns)!=="svelte-3npkmq"&&(Ns.textContent=tp),Xi.forEach(t),md=s(e),l(Ao.$$.fragment,e),fd=s(e),qe=i(e,"DIV",{class:!0});var Zi=_(qe);l(ko.$$.fragment,Zi),il=s(Zi),As=i(Zi,"P",{"data-svelte-h":!0}),f(As)!=="svelte-3npkmq"&&(As.textContent=op),Zi.forEach(t),_d=s(e),l(Po.$$.fragment,e),gd=s(e),Oe=i(e,"DIV",{class:!0});var Gi=_(Oe);l(Lo.$$.fragment,Gi),ul=s(Gi),ks=i(Gi,"P",{"data-svelte-h":!0}),f(ks)!=="svelte-1xezu93"&&(ks.textContent=np),Gi.forEach(t),Td=s(e),l(Bo.$$.fragment,e),bd=s(e),we=i(e,"DIV",{class:!0});var Yi=_(we);l(Wo.$$.fragment,Yi),ll=s(Yi),Ps=i(Yi,"P",{"data-svelte-h":!0}),f(Ps)!=="svelte-1dobm33"&&(Ps.textContent=sp),Yi.forEach(t),xd=s(e),l(jo.$$.fragment,e),vd=s(e),ye=i(e,"DIV",{class:!0});var Ki=_(ye);l(Do.$$.fragment,Ki),cl=s(Ki),Ls=i(Ki,"P",{"data-svelte-h":!0}),f(Ls)!=="svelte-1bm2i0r"&&(Ls.textContent=ap),Ki.forEach(t),$d=s(e),l(Io.$$.fragment,e),qd=s(e),Se=i(e,"DIV",{class:!0});var eu=_(Se);l(Vo.$$.fragment,eu),pl=s(eu),Bs=i(eu,"P",{"data-svelte-h":!0}),f(Bs)!=="svelte-o4u80u"&&(Bs.textContent=rp),eu.forEach(t),Od=s(e),l(Ho.$$.fragment,e),wd=s(e),Me=i(e,"DIV",{class:!0});var tu=_(Me);l(Eo.$$.fragment,tu),hl=s(tu),Ws=i(tu,"P",{"data-svelte-h":!0}),f(Ws)!=="svelte-1kfw2sn"&&(Ws.textContent=dp),tu.forEach(t),yd=s(e),l(Qo.$$.fragment,e),Sd=s(e),Fe=i(e,"DIV",{class:!0});var ou=_(Fe);l(Jo.$$.fragment,ou),ml=s(ou),js=i(ou,"P",{"data-svelte-h":!0}),f(js)!=="svelte-yql1ve"&&(js.textContent=ip),ou.forEach(t),Md=s(e),l(Uo.$$.fragment,e),Fd=s(e),Ce=i(e,"DIV",{class:!0});var nu=_(Ce);l(Ro.$$.fragment,nu),fl=s(nu),Ds=i(nu,"P",{"data-svelte-h":!0}),f(Ds)!=="svelte-1iv9pso"&&(Ds.textContent=up),nu.forEach(t),Cd=s(e),l(Xo.$$.fragment,e),zd=s(e),ze=i(e,"DIV",{class:!0});var su=_(ze);l(Zo.$$.fragment,su),_l=s(su),Is=i(su,"P",{"data-svelte-h":!0}),f(Is)!=="svelte-w7415f"&&(Is.textContent=lp),su.forEach(t),Nd=s(e),l(Go.$$.fragment,e),Ad=s(e),Ne=i(e,"DIV",{class:!0});var au=_(Ne);l(Yo.$$.fragment,au),gl=s(au),Vs=i(au,"P",{"data-svelte-h":!0}),f(Vs)!=="svelte-dhzux4"&&(Vs.textContent=cp),au.forEach(t),kd=s(e),l(Ko.$$.fragment,e),Pd=s(e),q=i(e,"DIV",{class:!0});var ba=_(q);l(en.$$.fragment,ba),Tl=s(ba),Hs=i(ba,"P",{"data-svelte-h":!0}),f(Hs)!=="svelte-19jpj19"&&(Hs.textContent=pp),bl=s(ba),Be=i(ba,"DIV",{class:!0});var ru=_(Be);l(tn.$$.fragment,ru),xl=s(ru),Es=i(ru,"P",{"data-svelte-h":!0}),f(Es)!=="svelte-5ihtpa"&&(Es.textContent=hp),ru.forEach(t),ba.forEach(t),Ld=s(e),l(on.$$.fragment,e),Bd=s(e),O=i(e,"DIV",{class:!0});var xa=_(O);l(nn.$$.fragment,xa),vl=s(xa),Qs=i(xa,"P",{"data-svelte-h":!0}),f(Qs)!=="svelte-19jpj19"&&(Qs.textContent=mp),$l=s(xa),We=i(xa,"DIV",{class:!0});var du=_(We);l(sn.$$.fragment,du),ql=s(du),Js=i(du,"P",{"data-svelte-h":!0}),f(Js)!=="svelte-5ihtpa"&&(Js.textContent=fp),du.forEach(t),xa.forEach(t),Wd=s(e),l(an.$$.fragment,e),jd=s(e),w=i(e,"DIV",{class:!0});var va=_(w);l(rn.$$.fragment,va),Ol=s(va),Us=i(va,"P",{"data-svelte-h":!0}),f(Us)!=="svelte-rzpgnp"&&(Us.textContent=_p),wl=s(va),je=i(va,"DIV",{class:!0});var iu=_(je);l(dn.$$.fragment,iu),yl=s(iu),Rs=i(iu,"P",{"data-svelte-h":!0}),f(Rs)!=="svelte-5ihtpa"&&(Rs.textContent=gp),iu.forEach(t),va.forEach(t),Dd=s(e),l(un.$$.fragment,e),Id=s(e),y=i(e,"DIV",{class:!0});var $a=_(y);l(ln.$$.fragment,$a),Sl=s($a),Xs=i($a,"P",{"data-svelte-h":!0}),f(Xs)!=="svelte-1kt4x95"&&(Xs.textContent=Tp),Ml=s($a),De=i($a,"DIV",{class:!0});var uu=_(De);l(cn.$$.fragment,uu),Fl=s(uu),Zs=i(uu,"P",{"data-svelte-h":!0}),f(Zs)!=="svelte-5ihtpa"&&(Zs.textContent=bp),uu.forEach(t),$a.forEach(t),Vd=s(e),l(pn.$$.fragment,e),Hd=s(e),S=i(e,"DIV",{class:!0});var qa=_(S);l(hn.$$.fragment,qa),Cl=s(qa),Gs=i(qa,"P",{"data-svelte-h":!0}),f(Gs)!=="svelte-k12cko"&&(Gs.textContent=xp),zl=s(qa),Ie=i(qa,"DIV",{class:!0});var lu=_(Ie);l(mn.$$.fragment,lu),Nl=s(lu),Ys=i(lu,"P",{"data-svelte-h":!0}),f(Ys)!=="svelte-5ihtpa"&&(Ys.textContent=vp),lu.forEach(t),qa.forEach(t),Ed=s(e),l(fn.$$.fragment,e),Qd=s(e),M=i(e,"DIV",{class:!0});var Oa=_(M);l(_n.$$.fragment,Oa),Al=s(Oa),Ks=i(Oa,"P",{"data-svelte-h":!0}),f(Ks)!=="svelte-3npkmq"&&(Ks.textContent=$p),kl=s(Oa),Ve=i(Oa,"DIV",{class:!0});var cu=_(Ve);l(gn.$$.fragment,cu),Pl=s(cu),ea=i(cu,"P",{"data-svelte-h":!0}),f(ea)!=="svelte-5ihtpa"&&(ea.textContent=qp),cu.forEach(t),Oa.forEach(t),Jd=s(e),l(Tn.$$.fragment,e),Ud=s(e),F=i(e,"DIV",{class:!0});var wa=_(F);l(bn.$$.fragment,wa),Ll=s(wa),ta=i(wa,"P",{"data-svelte-h":!0}),f(ta)!=="svelte-1xezu93"&&(ta.textContent=Op),Bl=s(wa),He=i(wa,"DIV",{class:!0});var pu=_(He);l(xn.$$.fragment,pu),Wl=s(pu),oa=i(pu,"P",{"data-svelte-h":!0}),f(oa)!=="svelte-5ihtpa"&&(oa.textContent=wp),pu.forEach(t),wa.forEach(t),Rd=s(e),l(vn.$$.fragment,e),Xd=s(e),C=i(e,"DIV",{class:!0});var ya=_(C);l($n.$$.fragment,ya),jl=s(ya),na=i(ya,"P",{"data-svelte-h":!0}),f(na)!=="svelte-1dobm33"&&(na.textContent=yp),Dl=s(ya),Ee=i(ya,"DIV",{class:!0});var hu=_(Ee);l(qn.$$.fragment,hu),Il=s(hu),sa=i(hu,"P",{"data-svelte-h":!0}),f(sa)!=="svelte-5ihtpa"&&(sa.textContent=Sp),hu.forEach(t),ya.forEach(t),Zd=s(e),l(On.$$.fragment,e),Gd=s(e),z=i(e,"DIV",{class:!0});var Sa=_(z);l(wn.$$.fragment,Sa),Vl=s(Sa),aa=i(Sa,"P",{"data-svelte-h":!0}),f(aa)!=="svelte-1bm2i0r"&&(aa.textContent=Mp),Hl=s(Sa),Qe=i(Sa,"DIV",{class:!0});var mu=_(Qe);l(yn.$$.fragment,mu),El=s(mu),ra=i(mu,"P",{"data-svelte-h":!0}),f(ra)!=="svelte-5ihtpa"&&(ra.textContent=Fp),mu.forEach(t),Sa.forEach(t),Yd=s(e),l(Sn.$$.fragment,e),Kd=s(e),N=i(e,"DIV",{class:!0});var Ma=_(N);l(Mn.$$.fragment,Ma),Ql=s(Ma),da=i(Ma,"P",{"data-svelte-h":!0}),f(da)!=="svelte-o4u80u"&&(da.textContent=Cp),Jl=s(Ma),Je=i(Ma,"DIV",{class:!0});var fu=_(Je);l(Fn.$$.fragment,fu),Ul=s(fu),ia=i(fu,"P",{"data-svelte-h":!0}),f(ia)!=="svelte-5ihtpa"&&(ia.textContent=zp),fu.forEach(t),Ma.forEach(t),ei=s(e),l(Cn.$$.fragment,e),ti=s(e),A=i(e,"DIV",{class:!0});var Fa=_(A);l(zn.$$.fragment,Fa),Rl=s(Fa),ua=i(Fa,"P",{"data-svelte-h":!0}),f(ua)!=="svelte-1kfw2sn"&&(ua.textContent=Np),Xl=s(Fa),Ue=i(Fa,"DIV",{class:!0});var _u=_(Ue);l(Nn.$$.fragment,_u),Zl=s(_u),la=i(_u,"P",{"data-svelte-h":!0}),f(la)!=="svelte-5ihtpa"&&(la.textContent=Ap),_u.forEach(t),Fa.forEach(t),oi=s(e),l(An.$$.fragment,e),ni=s(e),k=i(e,"DIV",{class:!0});var Ca=_(k);l(kn.$$.fragment,Ca),Gl=s(Ca),ca=i(Ca,"P",{"data-svelte-h":!0}),f(ca)!=="svelte-yql1ve"&&(ca.textContent=kp),Yl=s(Ca),Re=i(Ca,"DIV",{class:!0});var gu=_(Re);l(Pn.$$.fragment,gu),Kl=s(gu),pa=i(gu,"P",{"data-svelte-h":!0}),f(pa)!=="svelte-5ihtpa"&&(pa.textContent=Pp),gu.forEach(t),Ca.forEach(t),si=s(e),l(Ln.$$.fragment,e),ai=s(e),P=i(e,"DIV",{class:!0});var za=_(P);l(Bn.$$.fragment,za),ec=s(za),ha=i(za,"P",{"data-svelte-h":!0}),f(ha)!=="svelte-1iv9pso"&&(ha.textContent=Lp),tc=s(za),Xe=i(za,"DIV",{class:!0});var Tu=_(Xe);l(Wn.$$.fragment,Tu),oc=s(Tu),ma=i(Tu,"P",{"data-svelte-h":!0}),f(ma)!=="svelte-5ihtpa"&&(ma.textContent=Bp),Tu.forEach(t),za.forEach(t),ri=s(e),l(jn.$$.fragment,e),di=s(e),L=i(e,"DIV",{class:!0});var Na=_(L);l(Dn.$$.fragment,Na),nc=s(Na),fa=i(Na,"P",{"data-svelte-h":!0}),f(fa)!=="svelte-w7415f"&&(fa.textContent=Wp),sc=s(Na),Ze=i(Na,"DIV",{class:!0});var bu=_(Ze);l(In.$$.fragment,bu),ac=s(bu),_a=i(bu,"P",{"data-svelte-h":!0}),f(_a)!=="svelte-5ihtpa"&&(_a.textContent=jp),bu.forEach(t),Na.forEach(t),ii=s(e),l(Vn.$$.fragment,e),ui=s(e),B=i(e,"DIV",{class:!0});var Aa=_(B);l(Hn.$$.fragment,Aa),rc=s(Aa),ga=i(Aa,"P",{"data-svelte-h":!0}),f(ga)!=="svelte-dhzux4"&&(ga.textContent=Dp),dc=s(Aa),Ge=i(Aa,"DIV",{class:!0});var xu=_(Ge);l(En.$$.fragment,xu),ic=s(xu),Ta=i(xu,"P",{"data-svelte-h":!0}),f(Ta)!=="svelte-5ihtpa"&&(Ta.textContent=Ip),xu.forEach(t),Aa.forEach(t),li=s(e),l(Qn.$$.fragment,e),ci=s(e),ka=i(e,"P",{}),_(ka).forEach(t),this.h()},h(){g(x,"name","hf:doc:metadata"),g(x,"content",eh),g(Le,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g($,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(D,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(I,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(V,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(H,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(E,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Q,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(J,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(U,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(R,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(X,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(G,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Y,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(K,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(ee,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(te,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(oe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(ne,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(se,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(ae,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(re,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(de,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(ie,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(ue,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(le,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(ce,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(pe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(he,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(me,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(fe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(_e,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(ge,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Te,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(be,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(xe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(ve,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g($e,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(qe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Oe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(we,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(ye,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Se,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Me,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Fe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Ce,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(ze,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Ne,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Be,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(q,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(We,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(O,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(je,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(w,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(De,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(y,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Ie,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(S,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Ve,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(M,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(He,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(F,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Ee,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(C,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Qe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(z,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Je,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(N,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Ue,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(A,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Re,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(k,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Xe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(P,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Ze,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(L,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(Ge,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),g(B,"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,o){r(document.head,x),a(e,j,o),a(e,v,o),a(e,Ae,o),c(Ye,e,o),a(e,Pa,o),a(e,Ke,o),a(e,La,o),a(e,et,o),a(e,Ba,o),c(tt,e,o),a(e,Wa,o),a(e,ot,o),a(e,ja,o),c(ke,e,o),a(e,Da,o),a(e,nt,o),a(e,Ia,o),a(e,st,o),a(e,Va,o),c(at,e,o),a(e,Ha,o),a(e,rt,o),a(e,Ea,o),a(e,dt,o),a(e,Qa,o),a(e,it,o),a(e,Ja,o),c(ut,e,o),a(e,Ua,o),a(e,$,o),c(lt,$,null),r($,vu),r($,Rn),r($,$u),c(Pe,$,null),r($,qu),r($,Le),c(ct,Le,null),r(Le,Ou),r(Le,Xn),a(e,Ra,o),c(pt,e,o),a(e,Xa,o),a(e,D,o),c(ht,D,null),r(D,wu),r(D,Zn),a(e,Za,o),c(mt,e,o),a(e,Ga,o),a(e,I,o),c(ft,I,null),r(I,yu),r(I,Gn),a(e,Ya,o),c(_t,e,o),a(e,Ka,o),a(e,V,o),c(gt,V,null),r(V,Su),r(V,Yn),a(e,er,o),c(Tt,e,o),a(e,tr,o),a(e,H,o),c(bt,H,null),r(H,Mu),r(H,Kn),a(e,or,o),c(xt,e,o),a(e,nr,o),a(e,E,o),c(vt,E,null),r(E,Fu),r(E,es),a(e,sr,o),c($t,e,o),a(e,ar,o),a(e,Q,o),c(qt,Q,null),r(Q,Cu),r(Q,ts),a(e,rr,o),c(Ot,e,o),a(e,dr,o),a(e,J,o),c(wt,J,null),r(J,zu),r(J,os),a(e,ir,o),c(yt,e,o),a(e,ur,o),a(e,U,o),c(St,U,null),r(U,Nu),r(U,ns),a(e,lr,o),c(Mt,e,o),a(e,cr,o),a(e,R,o),c(Ft,R,null),r(R,Au),r(R,ss),a(e,pr,o),c(Ct,e,o),a(e,hr,o),a(e,X,o),c(zt,X,null),r(X,ku),r(X,as),a(e,mr,o),c(Nt,e,o),a(e,fr,o),a(e,Z,o),c(At,Z,null),r(Z,Pu),r(Z,rs),a(e,_r,o),c(kt,e,o),a(e,gr,o),a(e,G,o),c(Pt,G,null),r(G,Lu),r(G,ds),a(e,Tr,o),c(Lt,e,o),a(e,br,o),a(e,Y,o),c(Bt,Y,null),r(Y,Bu),r(Y,is),a(e,xr,o),c(Wt,e,o),a(e,vr,o),a(e,K,o),c(jt,K,null),r(K,Wu),r(K,us),a(e,$r,o),c(Dt,e,o),a(e,qr,o),a(e,ee,o),c(It,ee,null),r(ee,ju),r(ee,ls),a(e,Or,o),c(Vt,e,o),a(e,wr,o),a(e,te,o),c(Ht,te,null),r(te,Du),r(te,cs),a(e,yr,o),c(Et,e,o),a(e,Sr,o),a(e,oe,o),c(Qt,oe,null),r(oe,Iu),r(oe,ps),a(e,Mr,o),c(Jt,e,o),a(e,Fr,o),a(e,ne,o),c(Ut,ne,null),r(ne,Vu),r(ne,hs),a(e,Cr,o),c(Rt,e,o),a(e,zr,o),a(e,se,o),c(Xt,se,null),r(se,Hu),r(se,ms),a(e,Nr,o),c(Zt,e,o),a(e,Ar,o),a(e,ae,o),c(Gt,ae,null),r(ae,Eu),r(ae,fs),a(e,kr,o),c(Yt,e,o),a(e,Pr,o),a(e,re,o),c(Kt,re,null),r(re,Qu),r(re,_s),a(e,Lr,o),c(eo,e,o),a(e,Br,o),a(e,de,o),c(to,de,null),r(de,Ju),r(de,gs),a(e,Wr,o),c(oo,e,o),a(e,jr,o),a(e,ie,o),c(no,ie,null),r(ie,Uu),r(ie,Ts),a(e,Dr,o),c(so,e,o),a(e,Ir,o),a(e,ue,o),c(ao,ue,null),r(ue,Ru),r(ue,bs),a(e,Vr,o),c(ro,e,o),a(e,Hr,o),a(e,le,o),c(io,le,null),r(le,Xu),r(le,xs),a(e,Er,o),c(uo,e,o),a(e,Qr,o),a(e,ce,o),c(lo,ce,null),r(ce,Zu),r(ce,vs),a(e,Jr,o),c(co,e,o),a(e,Ur,o),a(e,pe,o),c(po,pe,null),r(pe,Gu),r(pe,$s),a(e,Rr,o),c(ho,e,o),a(e,Xr,o),a(e,he,o),c(mo,he,null),r(he,Yu),r(he,qs),a(e,Zr,o),c(fo,e,o),a(e,Gr,o),a(e,me,o),c(_o,me,null),r(me,Ku),r(me,Os),a(e,Yr,o),c(go,e,o),a(e,Kr,o),a(e,fe,o),c(To,fe,null),r(fe,el),r(fe,ws),a(e,ed,o),c(bo,e,o),a(e,td,o),a(e,_e,o),c(xo,_e,null),r(_e,tl),r(_e,ys),a(e,od,o),c(vo,e,o),a(e,nd,o),a(e,ge,o),c($o,ge,null),r(ge,ol),r(ge,Ss),a(e,sd,o),c(qo,e,o),a(e,ad,o),a(e,Te,o),c(Oo,Te,null),r(Te,nl),r(Te,Ms),a(e,rd,o),c(wo,e,o),a(e,dd,o),a(e,be,o),c(yo,be,null),r(be,sl),r(be,Fs),a(e,id,o),c(So,e,o),a(e,ud,o),a(e,xe,o),c(Mo,xe,null),r(xe,al),r(xe,Cs),a(e,ld,o),c(Fo,e,o),a(e,cd,o),a(e,ve,o),c(Co,ve,null),r(ve,rl),r(ve,zs),a(e,pd,o),c(zo,e,o),a(e,hd,o),a(e,$e,o),c(No,$e,null),r($e,dl),r($e,Ns),a(e,md,o),c(Ao,e,o),a(e,fd,o),a(e,qe,o),c(ko,qe,null),r(qe,il),r(qe,As),a(e,_d,o),c(Po,e,o),a(e,gd,o),a(e,Oe,o),c(Lo,Oe,null),r(Oe,ul),r(Oe,ks),a(e,Td,o),c(Bo,e,o),a(e,bd,o),a(e,we,o),c(Wo,we,null),r(we,ll),r(we,Ps),a(e,xd,o),c(jo,e,o),a(e,vd,o),a(e,ye,o),c(Do,ye,null),r(ye,cl),r(ye,Ls),a(e,$d,o),c(Io,e,o),a(e,qd,o),a(e,Se,o),c(Vo,Se,null),r(Se,pl),r(Se,Bs),a(e,Od,o),c(Ho,e,o),a(e,wd,o),a(e,Me,o),c(Eo,Me,null),r(Me,hl),r(Me,Ws),a(e,yd,o),c(Qo,e,o),a(e,Sd,o),a(e,Fe,o),c(Jo,Fe,null),r(Fe,ml),r(Fe,js),a(e,Md,o),c(Uo,e,o),a(e,Fd,o),a(e,Ce,o),c(Ro,Ce,null),r(Ce,fl),r(Ce,Ds),a(e,Cd,o),c(Xo,e,o),a(e,zd,o),a(e,ze,o),c(Zo,ze,null),r(ze,_l),r(ze,Is),a(e,Nd,o),c(Go,e,o),a(e,Ad,o),a(e,Ne,o),c(Yo,Ne,null),r(Ne,gl),r(Ne,Vs),a(e,kd,o),c(Ko,e,o),a(e,Pd,o),a(e,q,o),c(en,q,null),r(q,Tl),r(q,Hs),r(q,bl),r(q,Be),c(tn,Be,null),r(Be,xl),r(Be,Es),a(e,Ld,o),c(on,e,o),a(e,Bd,o),a(e,O,o),c(nn,O,null),r(O,vl),r(O,Qs),r(O,$l),r(O,We),c(sn,We,null),r(We,ql),r(We,Js),a(e,Wd,o),c(an,e,o),a(e,jd,o),a(e,w,o),c(rn,w,null),r(w,Ol),r(w,Us),r(w,wl),r(w,je),c(dn,je,null),r(je,yl),r(je,Rs),a(e,Dd,o),c(un,e,o),a(e,Id,o),a(e,y,o),c(ln,y,null),r(y,Sl),r(y,Xs),r(y,Ml),r(y,De),c(cn,De,null),r(De,Fl),r(De,Zs),a(e,Vd,o),c(pn,e,o),a(e,Hd,o),a(e,S,o),c(hn,S,null),r(S,Cl),r(S,Gs),r(S,zl),r(S,Ie),c(mn,Ie,null),r(Ie,Nl),r(Ie,Ys),a(e,Ed,o),c(fn,e,o),a(e,Qd,o),a(e,M,o),c(_n,M,null),r(M,Al),r(M,Ks),r(M,kl),r(M,Ve),c(gn,Ve,null),r(Ve,Pl),r(Ve,ea),a(e,Jd,o),c(Tn,e,o),a(e,Ud,o),a(e,F,o),c(bn,F,null),r(F,Ll),r(F,ta),r(F,Bl),r(F,He),c(xn,He,null),r(He,Wl),r(He,oa),a(e,Rd,o),c(vn,e,o),a(e,Xd,o),a(e,C,o),c($n,C,null),r(C,jl),r(C,na),r(C,Dl),r(C,Ee),c(qn,Ee,null),r(Ee,Il),r(Ee,sa),a(e,Zd,o),c(On,e,o),a(e,Gd,o),a(e,z,o),c(wn,z,null),r(z,Vl),r(z,aa),r(z,Hl),r(z,Qe),c(yn,Qe,null),r(Qe,El),r(Qe,ra),a(e,Yd,o),c(Sn,e,o),a(e,Kd,o),a(e,N,o),c(Mn,N,null),r(N,Ql),r(N,da),r(N,Jl),r(N,Je),c(Fn,Je,null),r(Je,Ul),r(Je,ia),a(e,ei,o),c(Cn,e,o),a(e,ti,o),a(e,A,o),c(zn,A,null),r(A,Rl),r(A,ua),r(A,Xl),r(A,Ue),c(Nn,Ue,null),r(Ue,Zl),r(Ue,la),a(e,oi,o),c(An,e,o),a(e,ni,o),a(e,k,o),c(kn,k,null),r(k,Gl),r(k,ca),r(k,Yl),r(k,Re),c(Pn,Re,null),r(Re,Kl),r(Re,pa),a(e,si,o),c(Ln,e,o),a(e,ai,o),a(e,P,o),c(Bn,P,null),r(P,ec),r(P,ha),r(P,tc),r(P,Xe),c(Wn,Xe,null),r(Xe,oc),r(Xe,ma),a(e,ri,o),c(jn,e,o),a(e,di,o),a(e,L,o),c(Dn,L,null),r(L,nc),r(L,fa),r(L,sc),r(L,Ze),c(In,Ze,null),r(Ze,ac),r(Ze,_a),a(e,ii,o),c(Vn,e,o),a(e,ui,o),a(e,B,o),c(Hn,B,null),r(B,rc),r(B,ga),r(B,dc),r(B,Ge),c(En,Ge,null),r(Ge,ic),r(Ge,Ta),a(e,li,o),c(Qn,e,o),a(e,ci,o),a(e,ka,o),pi=!0},p(e,[o]){const W={};o&2&&(W.$$scope={dirty:o,ctx:e}),ke.$set(W);const Jn={};o&2&&(Jn.$$scope={dirty:o,ctx:e}),Pe.$set(Jn)},i(e){pi||(p(Ye.$$.fragment,e),p(tt.$$.fragment,e),p(ke.$$.fragment,e),p(at.$$.fragment,e),p(ut.$$.fragment,e),p(lt.$$.fragment,e),p(Pe.$$.fragment,e),p(ct.$$.fragment,e),p(pt.$$.fragment,e),p(ht.$$.fragment,e),p(mt.$$.fragment,e),p(ft.$$.fragment,e),p(_t.$$.fragment,e),p(gt.$$.fragment,e),p(Tt.$$.fragment,e),p(bt.$$.fragment,e),p(xt.$$.fragment,e),p(vt.$$.fragment,e),p($t.$$.fragment,e),p(qt.$$.fragment,e),p(Ot.$$.fragment,e),p(wt.$$.fragment,e),p(yt.$$.fragment,e),p(St.$$.fragment,e),p(Mt.$$.fragment,e),p(Ft.$$.fragment,e),p(Ct.$$.fragment,e),p(zt.$$.fragment,e),p(Nt.$$.fragment,e),p(At.$$.fragment,e),p(kt.$$.fragment,e),p(Pt.$$.fragment,e),p(Lt.$$.fragment,e),p(Bt.$$.fragment,e),p(Wt.$$.fragment,e),p(jt.$$.fragment,e),p(Dt.$$.fragment,e),p(It.$$.fragment,e),p(Vt.$$.fragment,e),p(Ht.$$.fragment,e),p(Et.$$.fragment,e),p(Qt.$$.fragment,e),p(Jt.$$.fragment,e),p(Ut.$$.fragment,e),p(Rt.$$.fragment,e),p(Xt.$$.fragment,e),p(Zt.$$.fragment,e),p(Gt.$$.fragment,e),p(Yt.$$.fragment,e),p(Kt.$$.fragment,e),p(eo.$$.fragment,e),p(to.$$.fragment,e),p(oo.$$.fragment,e),p(no.$$.fragment,e),p(so.$$.fragment,e),p(ao.$$.fragment,e),p(ro.$$.fragment,e),p(io.$$.fragment,e),p(uo.$$.fragment,e),p(lo.$$.fragment,e),p(co.$$.fragment,e),p(po.$$.fragment,e),p(ho.$$.fragment,e),p(mo.$$.fragment,e),p(fo.$$.fragment,e),p(_o.$$.fragment,e),p(go.$$.fragment,e),p(To.$$.fragment,e),p(bo.$$.fragment,e),p(xo.$$.fragment,e),p(vo.$$.fragment,e),p($o.$$.fragment,e),p(qo.$$.fragment,e),p(Oo.$$.fragment,e),p(wo.$$.fragment,e),p(yo.$$.fragment,e),p(So.$$.fragment,e),p(Mo.$$.fragment,e),p(Fo.$$.fragment,e),p(Co.$$.fragment,e),p(zo.$$.fragment,e),p(No.$$.fragment,e),p(Ao.$$.fragment,e),p(ko.$$.fragment,e),p(Po.$$.fragment,e),p(Lo.$$.fragment,e),p(Bo.$$.fragment,e),p(Wo.$$.fragment,e),p(jo.$$.fragment,e),p(Do.$$.fragment,e),p(Io.$$.fragment,e),p(Vo.$$.fragment,e),p(Ho.$$.fragment,e),p(Eo.$$.fragment,e),p(Qo.$$.fragment,e),p(Jo.$$.fragment,e),p(Uo.$$.fragment,e),p(Ro.$$.fragment,e),p(Xo.$$.fragment,e),p(Zo.$$.fragment,e),p(Go.$$.fragment,e),p(Yo.$$.fragment,e),p(Ko.$$.fragment,e),p(en.$$.fragment,e),p(tn.$$.fragment,e),p(on.$$.fragment,e),p(nn.$$.fragment,e),p(sn.$$.fragment,e),p(an.$$.fragment,e),p(rn.$$.fragment,e),p(dn.$$.fragment,e),p(un.$$.fragment,e),p(ln.$$.fragment,e),p(cn.$$.fragment,e),p(pn.$$.fragment,e),p(hn.$$.fragment,e),p(mn.$$.fragment,e),p(fn.$$.fragment,e),p(_n.$$.fragment,e),p(gn.$$.fragment,e),p(Tn.$$.fragment,e),p(bn.$$.fragment,e),p(xn.$$.fragment,e),p(vn.$$.fragment,e),p($n.$$.fragment,e),p(qn.$$.fragment,e),p(On.$$.fragment,e),p(wn.$$.fragment,e),p(yn.$$.fragment,e),p(Sn.$$.fragment,e),p(Mn.$$.fragment,e),p(Fn.$$.fragment,e),p(Cn.$$.fragment,e),p(zn.$$.fragment,e),p(Nn.$$.fragment,e),p(An.$$.fragment,e),p(kn.$$.fragment,e),p(Pn.$$.fragment,e),p(Ln.$$.fragment,e),p(Bn.$$.fragment,e),p(Wn.$$.fragment,e),p(jn.$$.fragment,e),p(Dn.$$.fragment,e),p(In.$$.fragment,e),p(Vn.$$.fragment,e),p(Hn.$$.fragment,e),p(En.$$.fragment,e),p(Qn.$$.fragment,e),pi=!0)},o(e){h(Ye.$$.fragment,e),h(tt.$$.fragment,e),h(ke.$$.fragment,e),h(at.$$.fragment,e),h(ut.$$.fragment,e),h(lt.$$.fragment,e),h(Pe.$$.fragment,e),h(ct.$$.fragment,e),h(pt.$$.fragment,e),h(ht.$$.fragment,e),h(mt.$$.fragment,e),h(ft.$$.fragment,e),h(_t.$$.fragment,e),h(gt.$$.fragment,e),h(Tt.$$.fragment,e),h(bt.$$.fragment,e),h(xt.$$.fragment,e),h(vt.$$.fragment,e),h($t.$$.fragment,e),h(qt.$$.fragment,e),h(Ot.$$.fragment,e),h(wt.$$.fragment,e),h(yt.$$.fragment,e),h(St.$$.fragment,e),h(Mt.$$.fragment,e),h(Ft.$$.fragment,e),h(Ct.$$.fragment,e),h(zt.$$.fragment,e),h(Nt.$$.fragment,e),h(At.$$.fragment,e),h(kt.$$.fragment,e),h(Pt.$$.fragment,e),h(Lt.$$.fragment,e),h(Bt.$$.fragment,e),h(Wt.$$.fragment,e),h(jt.$$.fragment,e),h(Dt.$$.fragment,e),h(It.$$.fragment,e),h(Vt.$$.fragment,e),h(Ht.$$.fragment,e),h(Et.$$.fragment,e),h(Qt.$$.fragment,e),h(Jt.$$.fragment,e),h(Ut.$$.fragment,e),h(Rt.$$.fragment,e),h(Xt.$$.fragment,e),h(Zt.$$.fragment,e),h(Gt.$$.fragment,e),h(Yt.$$.fragment,e),h(Kt.$$.fragment,e),h(eo.$$.fragment,e),h(to.$$.fragment,e),h(oo.$$.fragment,e),h(no.$$.fragment,e),h(so.$$.fragment,e),h(ao.$$.fragment,e),h(ro.$$.fragment,e),h(io.$$.fragment,e),h(uo.$$.fragment,e),h(lo.$$.fragment,e),h(co.$$.fragment,e),h(po.$$.fragment,e),h(ho.$$.fragment,e),h(mo.$$.fragment,e),h(fo.$$.fragment,e),h(_o.$$.fragment,e),h(go.$$.fragment,e),h(To.$$.fragment,e),h(bo.$$.fragment,e),h(xo.$$.fragment,e),h(vo.$$.fragment,e),h($o.$$.fragment,e),h(qo.$$.fragment,e),h(Oo.$$.fragment,e),h(wo.$$.fragment,e),h(yo.$$.fragment,e),h(So.$$.fragment,e),h(Mo.$$.fragment,e),h(Fo.$$.fragment,e),h(Co.$$.fragment,e),h(zo.$$.fragment,e),h(No.$$.fragment,e),h(Ao.$$.fragment,e),h(ko.$$.fragment,e),h(Po.$$.fragment,e),h(Lo.$$.fragment,e),h(Bo.$$.fragment,e),h(Wo.$$.fragment,e),h(jo.$$.fragment,e),h(Do.$$.fragment,e),h(Io.$$.fragment,e),h(Vo.$$.fragment,e),h(Ho.$$.fragment,e),h(Eo.$$.fragment,e),h(Qo.$$.fragment,e),h(Jo.$$.fragment,e),h(Uo.$$.fragment,e),h(Ro.$$.fragment,e),h(Xo.$$.fragment,e),h(Zo.$$.fragment,e),h(Go.$$.fragment,e),h(Yo.$$.fragment,e),h(Ko.$$.fragment,e),h(en.$$.fragment,e),h(tn.$$.fragment,e),h(on.$$.fragment,e),h(nn.$$.fragment,e),h(sn.$$.fragment,e),h(an.$$.fragment,e),h(rn.$$.fragment,e),h(dn.$$.fragment,e),h(un.$$.fragment,e),h(ln.$$.fragment,e),h(cn.$$.fragment,e),h(pn.$$.fragment,e),h(hn.$$.fragment,e),h(mn.$$.fragment,e),h(fn.$$.fragment,e),h(_n.$$.fragment,e),h(gn.$$.fragment,e),h(Tn.$$.fragment,e),h(bn.$$.fragment,e),h(xn.$$.fragment,e),h(vn.$$.fragment,e),h($n.$$.fragment,e),h(qn.$$.fragment,e),h(On.$$.fragment,e),h(wn.$$.fragment,e),h(yn.$$.fragment,e),h(Sn.$$.fragment,e),h(Mn.$$.fragment,e),h(Fn.$$.fragment,e),h(Cn.$$.fragment,e),h(zn.$$.fragment,e),h(Nn.$$.fragment,e),h(An.$$.fragment,e),h(kn.$$.fragment,e),h(Pn.$$.fragment,e),h(Ln.$$.fragment,e),h(Bn.$$.fragment,e),h(Wn.$$.fragment,e),h(jn.$$.fragment,e),h(Dn.$$.fragment,e),h(In.$$.fragment,e),h(Vn.$$.fragment,e),h(Hn.$$.fragment,e),h(En.$$.fragment,e),h(Qn.$$.fragment,e),pi=!1},d(e){e&&(t(j),t(v),t(Ae),t(Pa),t(Ke),t(La),t(et),t(Ba),t(Wa),t(ot),t(ja),t(Da),t(nt),t(Ia),t(st),t(Va),t(Ha),t(rt),t(Ea),t(dt),t(Qa),t(it),t(Ja),t(Ua),t($),t(Ra),t(Xa),t(D),t(Za),t(Ga),t(I),t(Ya),t(Ka),t(V),t(er),t(tr),t(H),t(or),t(nr),t(E),t(sr),t(ar),t(Q),t(rr),t(dr),t(J),t(ir),t(ur),t(U),t(lr),t(cr),t(R),t(pr),t(hr),t(X),t(mr),t(fr),t(Z),t(_r),t(gr),t(G),t(Tr),t(br),t(Y),t(xr),t(vr),t(K),t($r),t(qr),t(ee),t(Or),t(wr),t(te),t(yr),t(Sr),t(oe),t(Mr),t(Fr),t(ne),t(Cr),t(zr),t(se),t(Nr),t(Ar),t(ae),t(kr),t(Pr),t(re),t(Lr),t(Br),t(de),t(Wr),t(jr),t(ie),t(Dr),t(Ir),t(ue),t(Vr),t(Hr),t(le),t(Er),t(Qr),t(ce),t(Jr),t(Ur),t(pe),t(Rr),t(Xr),t(he),t(Zr),t(Gr),t(me),t(Yr),t(Kr),t(fe),t(ed),t(td),t(_e),t(od),t(nd),t(ge),t(sd),t(ad),t(Te),t(rd),t(dd),t(be),t(id),t(ud),t(xe),t(ld),t(cd),t(ve),t(pd),t(hd),t($e),t(md),t(fd),t(qe),t(_d),t(gd),t(Oe),t(Td),t(bd),t(we),t(xd),t(vd),t(ye),t($d),t(qd),t(Se),t(Od),t(wd),t(Me),t(yd),t(Sd),t(Fe),t(Md),t(Fd),t(Ce),t(Cd),t(zd),t(ze),t(Nd),t(Ad),t(Ne),t(kd),t(Pd),t(q),t(Ld),t(Bd),t(O),t(Wd),t(jd),t(w),t(Dd),t(Id),t(y),t(Vd),t(Hd),t(S),t(Ed),t(Qd),t(M),t(Jd),t(Ud),t(F),t(Rd),t(Xd),t(C),t(Zd),t(Gd),t(z),t(Yd),t(Kd),t(N),t(ei),t(ti),t(A),t(oi),t(ni),t(k),t(si),t(ai),t(P),t(ri),t(di),t(L),t(ii),t(ui),t(B),t(li),t(ci),t(ka)),t(x),m(Ye,e),m(tt,e),m(ke,e),m(at,e),m(ut,e),m(lt),m(Pe),m(ct),m(pt,e),m(ht),m(mt,e),m(ft),m(_t,e),m(gt),m(Tt,e),m(bt),m(xt,e),m(vt),m($t,e),m(qt),m(Ot,e),m(wt),m(yt,e),m(St),m(Mt,e),m(Ft),m(Ct,e),m(zt),m(Nt,e),m(At),m(kt,e),m(Pt),m(Lt,e),m(Bt),m(Wt,e),m(jt),m(Dt,e),m(It),m(Vt,e),m(Ht),m(Et,e),m(Qt),m(Jt,e),m(Ut),m(Rt,e),m(Xt),m(Zt,e),m(Gt),m(Yt,e),m(Kt),m(eo,e),m(to),m(oo,e),m(no),m(so,e),m(ao),m(ro,e),m(io),m(uo,e),m(lo),m(co,e),m(po),m(ho,e),m(mo),m(fo,e),m(_o),m(go,e),m(To),m(bo,e),m(xo),m(vo,e),m($o),m(qo,e),m(Oo),m(wo,e),m(yo),m(So,e),m(Mo),m(Fo,e),m(Co),m(zo,e),m(No),m(Ao,e),m(ko),m(Po,e),m(Lo),m(Bo,e),m(Wo),m(jo,e),m(Do),m(Io,e),m(Vo),m(Ho,e),m(Eo),m(Qo,e),m(Jo),m(Uo,e),m(Ro),m(Xo,e),m(Zo),m(Go,e),m(Yo),m(Ko,e),m(en),m(tn),m(on,e),m(nn),m(sn),m(an,e),m(rn),m(dn),m(un,e),m(ln),m(cn),m(pn,e),m(hn),m(mn),m(fn,e),m(_n),m(gn),m(Tn,e),m(bn),m(xn),m(vn,e),m($n),m(qn),m(On,e),m(wn),m(yn),m(Sn,e),m(Mn),m(Fn),m(Cn,e),m(zn),m(Nn),m(An,e),m(kn),m(Pn),m(Ln,e),m(Bn),m(Wn),m(jn,e),m(Dn),m(In),m(Vn,e),m(Hn),m(En),m(Qn,e)}}}const eh='{"title":"모델 출력","local":"model-outputs","sections":[{"title":"ModelOutput","local":"transformers.utils.ModelOutput ][ transformers.utils.ModelOutput","sections":[],"depth":2},{"title":"BaseModelOutput","local":"transformers.BaseModelOutput ][ transformers.modeling_outputs.BaseModelOutput","sections":[],"depth":2},{"title":"BaseModelOutputWithPooling","local":"transformers.modeling_outputs.BaseModelOutputWithPooling ][ transformers.modeling_outputs.BaseModelOutputWithPooling","sections":[],"depth":2},{"title":"BaseModelOutputWithCrossAttentions","local":"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions ][ transformers.modeling_outputs.BaseModelOutputWithCrossAttentions","sections":[],"depth":2},{"title":"BaseModelOutputWithPoolingAndCrossAttentions","local":"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions ][ transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions","sections":[],"depth":2},{"title":"BaseModelOutputWithPast","local":"transformers.modeling_outputs.BaseModelOutputWithPast ][ transformers.modeling_outputs.BaseModelOutputWithPast","sections":[],"depth":2},{"title":"BaseModelOutputWithPastAndCrossAttentions","local":"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions ][ transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions","sections":[],"depth":2},{"title":"Seq2SeqModelOutput","local":"transformers.modeling_outputs.Seq2SeqModelOutput ][ transformers.modeling_outputs.Seq2SeqModelOutput","sections":[],"depth":2},{"title":"CausalLMOutput","local":"transformers.modeling_outputs.CausalLMOutput ][ transformers.modeling_outputs.CausalLMOutput","sections":[],"depth":2},{"title":"CausalLMOutputWithCrossAttentions","local":"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions ][ transformers.modeling_outputs.CausalLMOutputWithCrossAttentions","sections":[],"depth":2},{"title":"CausalLMOutputWithPast","local":"transformers.modeling_outputs.CausalLMOutputWithPast ][ transformers.modeling_outputs.CausalLMOutputWithPast","sections":[],"depth":2},{"title":"MaskedLMOutput","local":"transformers.modeling_outputs.MaskedLMOutput ][ transformers.modeling_outputs.MaskedLMOutput","sections":[],"depth":2},{"title":"Seq2SeqLMOutput","local":"transformers.modeling_outputs.Seq2SeqLMOutput ][ transformers.modeling_outputs.Seq2SeqLMOutput","sections":[],"depth":2},{"title":"NextSentencePredictorOutput","local":"transformers.modeling_outputs.NextSentencePredictorOutput ][ transformers.modeling_outputs.NextSentencePredictorOutput","sections":[],"depth":2},{"title":"SequenceClassifierOutput","local":"transformers.modeling_outputs.SequenceClassifierOutput ][ transformers.modeling_outputs.SequenceClassifierOutput","sections":[],"depth":2},{"title":"Seq2SeqSequenceClassifierOutput","local":"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput ][ transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput","sections":[],"depth":2},{"title":"MultipleChoiceModelOutput","local":"transformers.modeling_outputs.MultipleChoiceModelOutput ][ transformers.modeling_outputs.MultipleChoiceModelOutput","sections":[],"depth":2},{"title":"TokenClassifierOutput","local":"transformers.modeling_outputs.TokenClassifierOutput ][ transformers.modeling_outputs.TokenClassifierOutput","sections":[],"depth":2},{"title":"QuestionAnsweringModelOutput","local":"transformers.modeling_outputs.QuestionAnsweringModelOutput ][ transformers.modeling_outputs.QuestionAnsweringModelOutput","sections":[],"depth":2},{"title":"Seq2SeqQuestionAnsweringModelOutput","local":"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput ][ transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput","sections":[],"depth":2},{"title":"Seq2SeqSpectrogramOutput","local":"transformers.modeling_outputs.Seq2SeqSpectrogramOutput ][ transformers.modeling_outputs.Seq2SeqSpectrogramOutput","sections":[],"depth":2},{"title":"SemanticSegmenterOutput","local":"transformers.modeling_outputs.SemanticSegmenterOutput ][ transformers.modeling_outputs.SemanticSegmenterOutput","sections":[],"depth":2},{"title":"ImageClassifierOutput","local":"transformers.modeling_outputs.ImageClassifierOutput ][ transformers.modeling_outputs.ImageClassifierOutput","sections":[],"depth":2},{"title":"ImageClassifierOutputWithNoAttention","local":"transformers.modeling_outputs.ImageClassifierOutputWithNoAttention ][ transformers.modeling_outputs.ImageClassifierOutputWithNoAttention","sections":[],"depth":2},{"title":"DepthEstimatorOutput","local":"transformers.modeling_outputs.DepthEstimatorOutput ][ transformers.modeling_outputs.DepthEstimatorOutput","sections":[],"depth":2},{"title":"Wav2Vec2BaseModelOutput","local":"transformers.modeling_outputs.Wav2Vec2BaseModelOutput ][ transformers.modeling_outputs.Wav2Vec2BaseModelOutput","sections":[],"depth":2},{"title":"XVectorOutput","local":"transformers.modeling_outputs.XVectorOutput ][ transformers.modeling_outputs.XVectorOutput","sections":[],"depth":2},{"title":"Seq2SeqTSModelOutput","local":"transformers.modeling_outputs.Seq2SeqTSModelOutput ][ transformers.modeling_outputs.Seq2SeqTSModelOutput","sections":[],"depth":2},{"title":"Seq2SeqTSPredictionOutput","local":"transformers.modeling_outputs.Seq2SeqTSPredictionOutput ][ transformers.modeling_outputs.Seq2SeqTSPredictionOutput","sections":[],"depth":2},{"title":"SampleTSPredictionOutput","local":"transformers.modeling_outputs.SampleTSPredictionOutput ][ transformers.modeling_outputs.SampleTSPredictionOutput","sections":[],"depth":2},{"title":"TFBaseModelOutput","local":"transformers.modeling_outputs.TFBaseModelOutput ][ transformers.modeling_tf_outputs.TFBaseModelOutput","sections":[],"depth":2},{"title":"TFBaseModelOutputWithPooling","local":"transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling ][ transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling","sections":[],"depth":2},{"title":"TFBaseModelOutputWithPoolingAndCrossAttentions","local":"transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions ][ transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions","sections":[],"depth":2},{"title":"TFBaseModelOutputWithPast","local":"transformers.modeling_tf_outputs.TFBaseModelOutputWithPast ][ transformers.modeling_tf_outputs.TFBaseModelOutputWithPast","sections":[],"depth":2},{"title":"TFBaseModelOutputWithPastAndCrossAttentions","local":"transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions ][ transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions","sections":[],"depth":2},{"title":"TFSeq2SeqModelOutput","local":"transformers.modeling_tf_outputs.TFSeq2SeqModelOutput ][ transformers.modeling_tf_outputs.TFSeq2SeqModelOutput","sections":[],"depth":2},{"title":"TFCausalLMOutput","local":"transformers.modeling_tf_outputs.TFCausalLMOutput ][ transformers.modeling_tf_outputs.TFCausalLMOutput","sections":[],"depth":2},{"title":"TFCausalLMOutputWithCrossAttentions","local":"transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions ][ transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions","sections":[],"depth":2},{"title":"TFCausalLMOutputWithPast","local":"transformers.modeling_tf_outputs.TFCausalLMOutputWithPast ][ transformers.modeling_tf_outputs.TFCausalLMOutputWithPast","sections":[],"depth":2},{"title":"TFMaskedLMOutput","local":"transformers.modeling_tf_outputs.TFMaskedLMOutput ][ transformers.modeling_tf_outputs.TFMaskedLMOutput","sections":[],"depth":2},{"title":"TFSeq2SeqLMOutput","local":"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput ][ transformers.modeling_tf_outputs.TFSeq2SeqLMOutput","sections":[],"depth":2},{"title":"TFNextSentencePredictorOutput","local":"transformers.modeling_tf_outputs.TFNextSentencePredictorOutput ][ transformers.modeling_tf_outputs.TFNextSentencePredictorOutput","sections":[],"depth":2},{"title":"TFSequenceClassifierOutput","local":"transformers.modeling_tf_outputs.TFSequenceClassifierOutput ][ transformers.modeling_tf_outputs.TFSequenceClassifierOutput","sections":[],"depth":2},{"title":"TFSeq2SeqSequenceClassifierOutput","local":"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput ][ transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput","sections":[],"depth":2},{"title":"TFMultipleChoiceModelOutput","local":"transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput ][ transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput","sections":[],"depth":2},{"title":"TFTokenClassifierOutput","local":"transformers.modeling_tf_outputs.TFTokenClassifierOutput ][ transformers.modeling_tf_outputs.TFTokenClassifierOutput","sections":[],"depth":2},{"title":"TFQuestionAnsweringModelOutput","local":"transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput ][ transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput","sections":[],"depth":2},{"title":"TFSeq2SeqQuestionAnsweringModelOutput","local":"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput ][ transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput","sections":[],"depth":2},{"title":"FlaxBaseModelOutput","local":"transformers.modeling_flax_outputs.FlaxBaseModelOutput ][ transformers.modeling_flax_outputs.FlaxBaseModelOutput","sections":[],"depth":2},{"title":"FlaxBaseModelOutputWithPast","local":"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast ][ transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast","sections":[],"depth":2},{"title":"FlaxBaseModelOutputWithPooling","local":"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling ][ transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling","sections":[],"depth":2},{"title":"FlaxBaseModelOutputWithPastAndCrossAttentions","local":"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions ][ transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions","sections":[],"depth":2},{"title":"FlaxSeq2SeqModelOutput","local":"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput ][ transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput","sections":[],"depth":2},{"title":"FlaxCausalLMOutputWithCrossAttentions","local":"transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions ][ transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions","sections":[],"depth":2},{"title":"FlaxMaskedLMOutput","local":"transformers.modeling_flax_outputs.FlaxMaskedLMOutput ][ transformers.modeling_flax_outputs.FlaxMaskedLMOutput","sections":[],"depth":2},{"title":"FlaxSeq2SeqLMOutput","local":"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput ][ transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput","sections":[],"depth":2},{"title":"FlaxNextSentencePredictorOutput","local":"transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput ][ transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput","sections":[],"depth":2},{"title":"FlaxSequenceClassifierOutput","local":"transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput ][ transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput","sections":[],"depth":2},{"title":"FlaxSeq2SeqSequenceClassifierOutput","local":"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput ][ transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput","sections":[],"depth":2},{"title":"FlaxMultipleChoiceModelOutput","local":"transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput ][ transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput","sections":[],"depth":2},{"title":"FlaxTokenClassifierOutput","local":"transformers.modeling_flax_outputs.FlaxTokenClassifierOutput ][ transformers.modeling_flax_outputs.FlaxTokenClassifierOutput","sections":[],"depth":2},{"title":"FlaxQuestionAnsweringModelOutput","local":"transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput ][ transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput","sections":[],"depth":2},{"title":"FlaxSeq2SeqQuestionAnsweringModelOutput","local":"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput ][ transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput","sections":[],"depth":2}],"depth":1}';function th(Un){return Jp(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class ih extends Up{constructor(x){super(),Rp(this,x,th,Kp,Qp,{})}}export{ih as component};
