import{S as Cb,i as Nb,s as zb,e as n,k as i,w as h,t as p,M as Eb,c as s,d as t,m as d,a,x as f,h as c,b as r,F as o,g as l,y as _,q as m,o as g,B as v}from"../../chunks/vendor-4833417e.js";import{T as Pb}from"../../chunks/Tip-fffd6df1.js";import{D as y}from"../../chunks/Docstring-4f315ed9.js";import{C as Ab}from"../../chunks/CodeBlock-6a3d1b46.js";import{I as T}from"../../chunks/IconCopyLink-4b81c553.js";import"../../chunks/CopyButton-dacfbfaf.js";function Bb(Ia){let x,U,$,q,X,O,nn,Z;return{c(){x=n("p"),U=p("You can\u2019t unpack a "),$=n("code"),q=p("ModelOutput"),X=p(" directly. Use the "),O=n("a"),nn=p("to_tuple()"),Z=p(` method to convert it to a
tuple before.`),this.h()},l(ee){x=s(ee,"P",{});var k=a(x);U=c(k,"You can\u2019t unpack a "),$=s(k,"CODE",{});var C=a($);q=c(C,"ModelOutput"),C.forEach(t),X=c(k," directly. Use the "),O=s(k,"A",{href:!0});var xa=a(O);nn=c(xa,"to_tuple()"),xa.forEach(t),Z=c(k,` method to convert it to a
tuple before.`),k.forEach(t),this.h()},h(){r(O,"href","/docs/transformers/pr_15839/en/main_classes/output#transformers.file_utils.ModelOutput.to_tuple")},m(ee,k){l(ee,x,k),o(x,U),o(x,$),o($,q),o(x,X),o(x,O),o(O,nn),o(x,Z)},d(ee){ee&&t(x)}}}function Lb(Ia){let x,U,$,q,X,O,nn,Z,ee,k,C,xa,$a,Lh,jh,Mu,qa,Wh,ku,sn,Au,w,Dh,Va,Hh,Qh,Oa,Ih,Vh,Ra,Rh,Yh,Ya,Uh,Jh,Ua,Gh,Kh,Ja,Xh,Zh,Ga,ef,tf,Ka,of,nf,Xa,sf,af,Za,rf,df,er,uf,lf,tr,pf,cf,Cu,S,hf,or,ff,_f,nr,mf,gf,sr,vf,yf,ar,Tf,wf,Nu,F,bf,rr,xf,$f,ir,qf,Of,dr,Sf,Ff,ur,Mf,kf,zu,an,Eu,Lt,Af,lr,Cf,Nf,Pu,M,zf,pr,Ef,Pf,cr,Bf,Lf,hr,jf,Wf,fr,Df,Hf,Bu,Sa,Qf,Lu,te,jt,_r,rn,If,mr,Vf,ju,A,dn,Rf,oe,Yf,gr,Uf,Jf,vr,Gf,Kf,Xf,Wt,Zf,Dt,un,e_,ln,t_,yr,o_,n_,Wu,ne,Ht,Tr,pn,s_,wr,a_,Du,se,cn,r_,br,i_,Hu,ae,Qt,xr,hn,d_,$r,u_,Qu,re,fn,l_,qr,p_,Iu,ie,It,Or,_n,c_,Sr,h_,Vu,de,mn,f_,Fr,__,Ru,ue,Vt,Mr,gn,m_,kr,g_,Yu,le,vn,v_,Ar,y_,Uu,pe,Rt,Cr,yn,T_,Nr,w_,Ju,ce,Tn,b_,zr,x_,Gu,he,Yt,Er,wn,$_,Pr,q_,Ku,fe,bn,O_,Br,S_,Xu,_e,Ut,Lr,xn,F_,jr,M_,Zu,me,$n,k_,Wr,A_,el,ge,Jt,Dr,qn,C_,Hr,N_,tl,ve,On,z_,Qr,E_,ol,ye,Gt,Ir,Sn,P_,Vr,B_,nl,Te,Fn,L_,Rr,j_,sl,we,Kt,Yr,Mn,W_,Ur,D_,al,be,kn,H_,Jr,Q_,rl,xe,Xt,Gr,An,I_,Kr,V_,il,$e,Cn,R_,Xr,Y_,dl,qe,Zt,Zr,Nn,U_,ei,J_,ul,Oe,zn,G_,ti,K_,ll,Se,eo,oi,En,X_,ni,Z_,pl,Fe,Pn,em,si,tm,cl,Me,to,ai,Bn,om,ri,nm,hl,ke,Ln,sm,ii,am,fl,Ae,oo,di,jn,rm,ui,im,_l,Ce,Wn,dm,li,um,ml,Ne,no,pi,Dn,lm,ci,pm,gl,ze,Hn,cm,hi,hm,vl,Ee,so,fi,Qn,fm,_i,_m,yl,Pe,In,mm,mi,gm,Tl,Be,ao,gi,Vn,vm,vi,ym,wl,Le,Rn,Tm,yi,wm,bl,je,ro,Ti,Yn,bm,wi,xm,xl,We,Un,$m,bi,qm,$l,De,io,xi,Jn,Om,$i,Sm,ql,He,Gn,Fm,qi,Mm,Ol,Qe,uo,Oi,Kn,km,Si,Am,Sl,Ie,Xn,Cm,Fi,Nm,Fl,Ve,lo,Mi,Zn,zm,ki,Em,Ml,Re,es,Pm,Ai,Bm,kl,Ye,po,Ci,ts,Lm,Ni,jm,Al,Ue,os,Wm,zi,Dm,Cl,Je,co,Ei,ns,Hm,Pi,Qm,Nl,Ge,ss,Im,Bi,Vm,zl,Ke,ho,Li,as,Rm,ji,Ym,El,Xe,rs,Um,Wi,Jm,Pl,Ze,fo,Di,is,Gm,Hi,Km,Bl,et,ds,Xm,Qi,Zm,Ll,tt,_o,Ii,us,eg,Vi,tg,jl,ot,ls,og,Ri,ng,Wl,nt,mo,Yi,ps,sg,Ui,ag,Dl,st,cs,rg,Ji,ig,Hl,at,go,Gi,hs,dg,Ki,ug,Ql,rt,fs,lg,Xi,pg,Il,it,vo,Zi,_s,cg,ed,hg,Vl,dt,ms,fg,td,_g,Rl,ut,yo,od,gs,mg,nd,gg,Yl,lt,vs,vg,sd,yg,Ul,pt,To,ad,ys,Tg,rd,wg,Jl,ct,Ts,bg,id,xg,Gl,ht,wo,dd,ws,$g,ud,qg,Kl,ft,bs,Og,ld,Sg,Xl,_t,bo,pd,xs,Fg,cd,Mg,Zl,mt,$s,kg,hd,Ag,ep,gt,xo,fd,qs,Cg,_d,Ng,tp,vt,Os,zg,md,Eg,op,yt,$o,gd,Ss,Pg,vd,Bg,np,Tt,Fs,Lg,yd,jg,sp,wt,qo,Td,Ms,Wg,wd,Dg,ap,bt,ks,Hg,bd,Qg,rp,xt,Oo,xd,As,Ig,$d,Vg,ip,N,Cs,Rg,qd,Yg,Ug,So,Ns,Jg,Od,Gg,dp,$t,Fo,Sd,zs,Kg,Fd,Xg,up,z,Es,Zg,Md,ev,tv,Mo,Ps,ov,kd,nv,lp,qt,ko,Ad,Bs,sv,Cd,av,pp,E,Ls,rv,Nd,iv,dv,Ao,js,uv,zd,lv,cp,Ot,Co,Ed,Ws,pv,Pd,cv,hp,P,Ds,hv,Bd,fv,_v,No,Hs,mv,Ld,gv,fp,St,zo,jd,Qs,vv,Wd,yv,_p,B,Is,Tv,Dd,wv,bv,Eo,Vs,xv,Hd,$v,mp,Ft,Po,Qd,Rs,qv,Id,Ov,gp,L,Ys,Sv,Vd,Fv,Mv,Bo,Us,kv,Rd,Av,vp,Mt,Lo,Yd,Js,Cv,Ud,Nv,yp,j,Gs,zv,Jd,Ev,Pv,jo,Ks,Bv,Gd,Lv,Tp,kt,Wo,Kd,Xs,jv,Xd,Wv,wp,W,Zs,Dv,Zd,Hv,Qv,Do,ea,Iv,eu,Vv,bp,At,Ho,tu,ta,Rv,ou,Yv,xp,D,oa,Uv,nu,Jv,Gv,Qo,na,Kv,su,Xv,$p,Ct,Io,au,sa,Zv,ru,ey,qp,H,aa,ty,iu,oy,ny,Vo,ra,sy,du,ay,Op,Nt,Ro,uu,ia,ry,lu,iy,Sp,Q,da,dy,pu,uy,ly,Yo,ua,py,cu,cy,Fp,zt,Uo,hu,la,hy,fu,fy,Mp,I,pa,_y,_u,my,gy,Jo,ca,vy,mu,yy,kp,Et,Go,gu,ha,Ty,vu,wy,Ap,V,fa,by,yu,xy,$y,Ko,_a,qy,Tu,Oy,Cp,Pt,Xo,wu,ma,Sy,bu,Fy,Np,R,ga,My,xu,ky,Ay,Zo,va,Cy,$u,Ny,zp,Bt,en,qu,ya,zy,Ou,Ey,Ep,Y,Ta,Py,Su,By,Ly,tn,wa,jy,Fu,Wy,Pp;return O=new T({}),sn=new Ab({props:{code:`from transformers import BertTokenizer, BertForSequenceClassification
import torch

tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
model = BertForSequenceClassification.from_pretrained("bert-base-uncased")

inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
labels = torch.tensor([1]).unsqueeze(0)  # Batch size 1
outputs = model(**inputs, labels=labels)`,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;bert-base-uncased&quot;</span>)
model = BertForSequenceClassification.from_pretrained(<span class="hljs-string">&quot;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"># Batch size 1</span>
outputs = model(**inputs, labels=labels)`}}),an=new Ab({props:{code:"outputs[:2]",highlighted:'outputs[:<span class="hljs-number">2</span>]'}}),rn=new T({}),dn=new y({props:{name:"class transformers.file_utils.ModelOutput",anchor:"transformers.file_utils.ModelOutput",parameters:"",source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/file_utils.py#L2614"}}),Wt=new Pb({props:{warning:"&lcub;true}",$$slots:{default:[Bb]},$$scope:{ctx:Ia}}}),un=new y({props:{name:"to_tuple",anchor:"transformers.file_utils.ModelOutput.to_tuple",parameters:[],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/file_utils.py#L2703"}}),pn=new T({}),cn=new y({props:{name:"class transformers.modeling_outputs.BaseModelOutput",anchor:"transformers.modeling_outputs.BaseModelOutput",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L24",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 + 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.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"}]}}),hn=new T({}),fn=new y({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:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L50",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 + 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.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"}]}}),_n=new T({}),mn=new y({props:{name:"class transformers.modeling_outputs.BaseModelOutputWithCrossAttentions",anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L121",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 + 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.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"}]}}),gn=new T({}),vn=new y({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:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L154",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 + 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.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"}]}}),yn=new T({}),Tn=new y({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:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L82",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 + 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.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"}]}}),wn=new T({}),bn=new y({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:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L203",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 + 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.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"}]}}),xn=new T({}),$n=new y({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:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[torch.FloatTensor] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L249",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 + 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.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 + 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.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"}]}}),qn=new T({}),On=new y({props:{name:"class transformers.modeling_outputs.CausalLMOutput",anchor:"transformers.modeling_outputs.CausalLMOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L310",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 + 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.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"}]}}),Sn=new T({}),Fn=new y({props:{name:"class transformers.modeling_outputs.CausalLMOutputWithCrossAttentions",anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L375",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 + 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.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"}]}}),Mn=new T({}),kn=new y({props:{name:"class transformers.modeling_outputs.CausalLMOutputWithPast",anchor:"transformers.modeling_outputs.CausalLMOutputWithPast",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L339",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 + 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.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"}]}}),An=new T({}),Cn=new y({props:{name:"class transformers.modeling_outputs.MaskedLMOutput",anchor:"transformers.modeling_outputs.MaskedLMOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L455",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 + 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.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"}]}}),Nn=new T({}),zn=new y({props:{name:"class transformers.modeling_outputs.Seq2SeqLMOutput",anchor:"transformers.modeling_outputs.Seq2SeqLMOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[torch.FloatTensor] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L484",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 + 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 + 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"}]}}),En=new T({}),Pn=new y({props:{name:"class transformers.modeling_outputs.NextSentencePredictorOutput",anchor:"transformers.modeling_outputs.NextSentencePredictorOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L544",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 + 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.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"}]}}),Bn=new T({}),Ln=new y({props:{name:"class transformers.modeling_outputs.SequenceClassifierOutput",anchor:"transformers.modeling_outputs.SequenceClassifierOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L574",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 + 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.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"}]}}),jn=new T({}),Wn=new y({props:{name:"class transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput",anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[torch.FloatTensor] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L603",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 + 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 + 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"}]}}),Dn=new T({}),Hn=new y({props:{name:"class transformers.modeling_outputs.MultipleChoiceModelOutput",anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L663",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 + 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.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"}]}}),Qn=new T({}),In=new y({props:{name:"class transformers.modeling_outputs.TokenClassifierOutput",anchor:"transformers.modeling_outputs.TokenClassifierOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L694",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 + 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.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"}]}}),Vn=new T({}),Rn=new y({props:{name:"class transformers.modeling_outputs.QuestionAnsweringModelOutput",anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"start_logits",val:": FloatTensor = None"},{name:"end_logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L723",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 + 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.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"}]}}),Yn=new T({}),Un=new y({props:{name:"class transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput",anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"start_logits",val:": FloatTensor = None"},{name:"end_logits",val:": FloatTensor = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[torch.FloatTensor] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_outputs.py#L755",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 + 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 + 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"}]}}),Jn=new T({}),Gn=new y({props:{name:"class transformers.modeling_tf_outputs.TFBaseModelOutput",anchor:"transformers.modeling_tf_outputs.TFBaseModelOutput",parameters:[{name:"last_hidden_state",val:": Tensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L24",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"}]}}),Kn=new T({}),Xn=new y({props:{name:"class transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling",anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling",parameters:[{name:"last_hidden_state",val:": Tensor = None"},{name:"pooler_output",val:": Tensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L50",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"}]}}),Zn=new T({}),es=new y({props:{name:"class transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions",anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions",parameters:[{name:"last_hidden_state",val:": Tensor = None"},{name:"pooler_output",val:": Tensor = None"},{name:"past_key_values",val:": typing.Optional[typing.List[tensorflow.python.framework.ops.Tensor]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L84",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"}]}}),ts=new T({}),os=new y({props:{name:"class transformers.modeling_tf_outputs.TFBaseModelOutputWithPast",anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPast",parameters:[{name:"last_hidden_state",val:": Tensor = None"},{name:"past_key_values",val:": typing.Optional[typing.List[tensorflow.python.framework.ops.Tensor]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L132",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"}]}}),ns=new T({}),ss=new y({props:{name:"class transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions",anchor:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions",parameters:[{name:"last_hidden_state",val:": Tensor = None"},{name:"past_key_values",val:": typing.Optional[typing.List[tensorflow.python.framework.ops.Tensor]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L201",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"}]}}),as=new T({}),rs=new y({props:{name:"class transformers.modeling_tf_outputs.TFSeq2SeqModelOutput",anchor:"transformers.modeling_tf_outputs.TFSeq2SeqModelOutput",parameters:[{name:"last_hidden_state",val:": Tensor = None"},{name:"past_key_values",val:": typing.Optional[typing.List[tensorflow.python.framework.ops.Tensor]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L244",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"}]}}),is=new T({}),ds=new y({props:{name:"class transformers.modeling_tf_outputs.TFCausalLMOutput",anchor:"transformers.modeling_tf_outputs.TFCausalLMOutput",parameters:[{name:"loss",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"logits",val:": Tensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L304",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"}]}}),us=new T({}),ls=new y({props:{name:"class transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions",anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions",parameters:[{name:"loss",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"logits",val:": Tensor = None"},{name:"past_key_values",val:": typing.Optional[typing.List[tensorflow.python.framework.ops.Tensor]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L369",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"}]}}),ps=new T({}),cs=new y({props:{name:"class transformers.modeling_tf_outputs.TFCausalLMOutputWithPast",anchor:"transformers.modeling_tf_outputs.TFCausalLMOutputWithPast",parameters:[{name:"loss",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"logits",val:": Tensor = None"},{name:"past_key_values",val:": typing.Optional[typing.List[tensorflow.python.framework.ops.Tensor]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L333",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"}]}}),hs=new T({}),fs=new y({props:{name:"class transformers.modeling_tf_outputs.TFMaskedLMOutput",anchor:"transformers.modeling_tf_outputs.TFMaskedLMOutput",parameters:[{name:"loss",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"logits",val:": Tensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L412",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"}]}}),_s=new T({}),ms=new y({props:{name:"class transformers.modeling_tf_outputs.TFSeq2SeqLMOutput",anchor:"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput",parameters:[{name:"loss",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"logits",val:": Tensor = None"},{name:"past_key_values",val:": typing.Optional[typing.List[tensorflow.python.framework.ops.Tensor]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L441",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"}]}}),gs=new T({}),vs=new y({props:{name:"class transformers.modeling_tf_outputs.TFNextSentencePredictorOutput",anchor:"transformers.modeling_tf_outputs.TFNextSentencePredictorOutput",parameters:[{name:"loss",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"logits",val:": Tensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L500",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"}]}}),ys=new T({}),Ts=new y({props:{name:"class transformers.modeling_tf_outputs.TFSequenceClassifierOutput",anchor:"transformers.modeling_tf_outputs.TFSequenceClassifierOutput",parameters:[{name:"loss",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"logits",val:": Tensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L530",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"}]}}),ws=new T({}),bs=new y({props:{name:"class transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput",anchor:"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput",parameters:[{name:"loss",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"logits",val:": Tensor = None"},{name:"past_key_values",val:": typing.Optional[typing.List[tensorflow.python.framework.ops.Tensor]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L559",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.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"}]}}),xs=new T({}),$s=new y({props:{name:"class transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput",anchor:"transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput",parameters:[{name:"loss",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"logits",val:": Tensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L611",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"}]}}),qs=new T({}),Os=new y({props:{name:"class transformers.modeling_tf_outputs.TFTokenClassifierOutput",anchor:"transformers.modeling_tf_outputs.TFTokenClassifierOutput",parameters:[{name:"loss",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"logits",val:": Tensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L642",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"}]}}),Ss=new T({}),Fs=new y({props:{name:"class transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput",anchor:"transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput",parameters:[{name:"loss",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"start_logits",val:": Tensor = None"},{name:"end_logits",val:": Tensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L671",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"}]}}),Ms=new T({}),ks=new y({props:{name:"class transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput",anchor:"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput",parameters:[{name:"loss",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"start_logits",val:": Tensor = None"},{name:"end_logits",val:": Tensor = None"},{name:"past_key_values",val:": typing.Optional[typing.List[tensorflow.python.framework.ops.Tensor]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[tensorflow.python.framework.ops.Tensor] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[tensorflow.python.framework.ops.Tensor]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_tf_outputs.py#L703",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"}]}}),As=new T({}),Cs=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxBaseModelOutput",anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutput",parameters:[{name:"last_hidden_state",val:": ndarray = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L23",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"}]}}),Ns=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),zs=new T({}),Es=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast",anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast",parameters:[{name:"last_hidden_state",val:": ndarray = None"},{name:"past_key_values",val:": typing.Union[typing.Dict[str, jax._src.numpy.lax_numpy.ndarray], NoneType] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L49",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"}]}}),Ps=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),Bs=new T({}),Ls=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling",anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling",parameters:[{name:"last_hidden_state",val:": ndarray = None"},{name:"pooler_output",val:": ndarray = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L79",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"}]}}),js=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),Ws=new T({}),Ds=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions",anchor:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions",parameters:[{name:"last_hidden_state",val:": ndarray = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L110",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"}]}}),Hs=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),Qs=new T({}),Is=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput",anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput",parameters:[{name:"last_hidden_state",val:": ndarray = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[jax._src.numpy.lax_numpy.ndarray] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L156",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"}]}}),Vs=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),Rs=new T({}),Ys=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions",anchor:"transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions",parameters:[{name:"logits",val:": ndarray = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L217",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"}]}}),Us=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),Js=new T({}),Gs=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxMaskedLMOutput",anchor:"transformers.modeling_flax_outputs.FlaxMaskedLMOutput",parameters:[{name:"logits",val:": ndarray = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L258",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"}]}}),Ks=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),Xs=new T({}),Zs=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput",anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput",parameters:[{name:"logits",val:": ndarray = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[jax._src.numpy.lax_numpy.ndarray] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L287",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"}]}}),ea=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),ta=new T({}),oa=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput",anchor:"transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput",parameters:[{name:"logits",val:": ndarray = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L344",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"}]}}),na=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),sa=new T({}),aa=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput",anchor:"transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput",parameters:[{name:"logits",val:": ndarray = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L371",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"}]}}),ra=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),ia=new T({}),da=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput",anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput",parameters:[{name:"logits",val:": ndarray = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[jax._src.numpy.lax_numpy.ndarray] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L397",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"}]}}),ua=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),la=new T({}),pa=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput",anchor:"transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput",parameters:[{name:"logits",val:": ndarray = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L454",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"}]}}),ca=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),ha=new T({}),fa=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxTokenClassifierOutput",anchor:"transformers.modeling_flax_outputs.FlaxTokenClassifierOutput",parameters:[{name:"logits",val:": ndarray = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L482",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"}]}}),_a=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),ma=new T({}),ga=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput",anchor:"transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput",parameters:[{name:"start_logits",val:": ndarray = None"},{name:"end_logits",val:": ndarray = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L508",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"}]}}),va=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),ya=new T({}),Ta=new y({props:{name:"class transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput",anchor:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput",parameters:[{name:"start_logits",val:": ndarray = None"},{name:"end_logits",val:": ndarray = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[jax._src.numpy.lax_numpy.ndarray] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[jax._src.numpy.lax_numpy.ndarray]] = None"}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/transformers/modeling_flax_outputs.py#L537",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"}]}}),wa=new y({props:{name:"replace",anchor:"None",parameters:[{name:"**updates",val:""}],source:"https://github.com/huggingface/transformers/blob/pr_15839/src/flax/struct.py#L120"}}),{c(){x=n("meta"),U=i(),$=n("h1"),q=n("a"),X=n("span"),h(O.$$.fragment),nn=i(),Z=n("span"),ee=p("Model outputs"),k=i(),C=n("p"),xa=p("All models have outputs that are instances of subclasses of "),$a=n("a"),Lh=p("ModelOutput"),jh=p(`. Those are
data structures containing all the information returned by the model, but that can also be used as tuples or
dictionaries.`),Mu=i(),qa=n("p"),Wh=p("Let\u2019s see of this looks on an example:"),ku=i(),h(sn.$$.fragment),Au=i(),w=n("p"),Dh=p("The "),Va=n("code"),Hh=p("outputs"),Qh=p(" object is a "),Oa=n("a"),Ih=p("SequenceClassifierOutput"),Vh=p(`, as we can see in the
documentation of that class below, it means it has an optional `),Ra=n("code"),Rh=p("loss"),Yh=p(", a "),Ya=n("code"),Uh=p("logits"),Jh=p(" an optional "),Ua=n("code"),Gh=p("hidden_states"),Kh=p(` and
an optional `),Ja=n("code"),Xh=p("attentions"),Zh=p(" attribute. Here we have the "),Ga=n("code"),ef=p("loss"),tf=p(" since we passed along "),Ka=n("code"),of=p("labels"),nf=p(`, but we don\u2019t have
`),Xa=n("code"),sf=p("hidden_states"),af=p(" and "),Za=n("code"),rf=p("attentions"),df=p(" because we didn\u2019t pass "),er=n("code"),uf=p("output_hidden_states=True"),lf=p(` or
`),tr=n("code"),pf=p("output_attentions=True"),cf=p("."),Cu=i(),S=n("p"),hf=p(`You can access each attribute as you would usually do, and if that attribute has not been returned by the model, you
will get `),or=n("code"),ff=p("None"),_f=p(". Here for instance "),nr=n("code"),mf=p("outputs.loss"),gf=p(" is the loss computed by the model, and "),sr=n("code"),vf=p("outputs.attentions"),yf=p(` is
`),ar=n("code"),Tf=p("None"),wf=p("."),Nu=i(),F=n("p"),bf=p("When considering our "),rr=n("code"),xf=p("outputs"),$f=p(" object as tuple, it only considers the attributes that don\u2019t have "),ir=n("code"),qf=p("None"),Of=p(` values.
Here for instance, it has two elements, `),dr=n("code"),Sf=p("loss"),Ff=p(" then "),ur=n("code"),Mf=p("logits"),kf=p(", so"),zu=i(),h(an.$$.fragment),Eu=i(),Lt=n("p"),Af=p("will return the tuple "),lr=n("code"),Cf=p("(outputs.loss, outputs.logits)"),Nf=p(" for instance."),Pu=i(),M=n("p"),zf=p("When considering our "),pr=n("code"),Ef=p("outputs"),Pf=p(" object as dictionary, it only considers the attributes that don\u2019t have "),cr=n("code"),Bf=p("None"),Lf=p(`
values. Here for instance, it has two keys that are `),hr=n("code"),jf=p("loss"),Wf=p(" and "),fr=n("code"),Df=p("logits"),Hf=p("."),Bu=i(),Sa=n("p"),Qf=p(`We document here the generic model outputs that are used by more than one model type. Specific output types are
documented on their corresponding model page.`),Lu=i(),te=n("h2"),jt=n("a"),_r=n("span"),h(rn.$$.fragment),If=i(),mr=n("span"),Vf=p("ModelOutput"),ju=i(),A=n("div"),h(dn.$$.fragment),Rf=i(),oe=n("p"),Yf=p("Base class for all model outputs as dataclass. Has a "),gr=n("code"),Uf=p("__getitem__"),Jf=p(` that allows indexing by integer or slice (like a
tuple) or strings (like a dictionary) that will ignore the `),vr=n("code"),Gf=p("None"),Kf=p(` attributes. Otherwise behaves like a regular
python dictionary.`),Xf=i(),h(Wt.$$.fragment),Zf=i(),Dt=n("div"),h(un.$$.fragment),e_=i(),ln=n("p"),t_=p("Convert self to a tuple containing all the attributes/keys that are not "),yr=n("code"),o_=p("None"),n_=p("."),Wu=i(),ne=n("h2"),Ht=n("a"),Tr=n("span"),h(pn.$$.fragment),s_=i(),wr=n("span"),a_=p("BaseModelOutput"),Du=i(),se=n("div"),h(cn.$$.fragment),r_=i(),br=n("p"),i_=p("Base class for model\u2019s outputs, with potential hidden states and attentions."),Hu=i(),ae=n("h2"),Qt=n("a"),xr=n("span"),h(hn.$$.fragment),d_=i(),$r=n("span"),u_=p("BaseModelOutputWithPooling"),Qu=i(),re=n("div"),h(fn.$$.fragment),l_=i(),qr=n("p"),p_=p("Base class for model\u2019s outputs that also contains a pooling of the last hidden states."),Iu=i(),ie=n("h2"),It=n("a"),Or=n("span"),h(_n.$$.fragment),c_=i(),Sr=n("span"),h_=p("BaseModelOutputWithCrossAttentions"),Vu=i(),de=n("div"),h(mn.$$.fragment),f_=i(),Fr=n("p"),__=p("Base class for model\u2019s outputs, with potential hidden states and attentions."),Ru=i(),ue=n("h2"),Vt=n("a"),Mr=n("span"),h(gn.$$.fragment),m_=i(),kr=n("span"),g_=p("BaseModelOutputWithPoolingAndCrossAttentions"),Yu=i(),le=n("div"),h(vn.$$.fragment),v_=i(),Ar=n("p"),y_=p("Base class for model\u2019s outputs that also contains a pooling of the last hidden states."),Uu=i(),pe=n("h2"),Rt=n("a"),Cr=n("span"),h(yn.$$.fragment),T_=i(),Nr=n("span"),w_=p("BaseModelOutputWithPast"),Ju=i(),ce=n("div"),h(Tn.$$.fragment),b_=i(),zr=n("p"),x_=p("Base class for model\u2019s outputs that may also contain a past key/values (to speed up sequential decoding)."),Gu=i(),he=n("h2"),Yt=n("a"),Er=n("span"),h(wn.$$.fragment),$_=i(),Pr=n("span"),q_=p("BaseModelOutputWithPastAndCrossAttentions"),Ku=i(),fe=n("div"),h(bn.$$.fragment),O_=i(),Br=n("p"),S_=p("Base class for model\u2019s outputs that may also contain a past key/values (to speed up sequential decoding)."),Xu=i(),_e=n("h2"),Ut=n("a"),Lr=n("span"),h(xn.$$.fragment),F_=i(),jr=n("span"),M_=p("Seq2SeqModelOutput"),Zu=i(),me=n("div"),h($n.$$.fragment),k_=i(),Wr=n("p"),A_=p(`Base class for model encoder\u2019s outputs that also contains : pre-computed hidden states that can speed up sequential
decoding.`),el=i(),ge=n("h2"),Jt=n("a"),Dr=n("span"),h(qn.$$.fragment),C_=i(),Hr=n("span"),N_=p("CausalLMOutput"),tl=i(),ve=n("div"),h(On.$$.fragment),z_=i(),Qr=n("p"),E_=p("Base class for causal language model (or autoregressive) outputs."),ol=i(),ye=n("h2"),Gt=n("a"),Ir=n("span"),h(Sn.$$.fragment),P_=i(),Vr=n("span"),B_=p("CausalLMOutputWithCrossAttentions"),nl=i(),Te=n("div"),h(Fn.$$.fragment),L_=i(),Rr=n("p"),j_=p("Base class for causal language model (or autoregressive) outputs."),sl=i(),we=n("h2"),Kt=n("a"),Yr=n("span"),h(Mn.$$.fragment),W_=i(),Ur=n("span"),D_=p("CausalLMOutputWithPast"),al=i(),be=n("div"),h(kn.$$.fragment),H_=i(),Jr=n("p"),Q_=p("Base class for causal language model (or autoregressive) outputs."),rl=i(),xe=n("h2"),Xt=n("a"),Gr=n("span"),h(An.$$.fragment),I_=i(),Kr=n("span"),V_=p("MaskedLMOutput"),il=i(),$e=n("div"),h(Cn.$$.fragment),R_=i(),Xr=n("p"),Y_=p("Base class for masked language models outputs."),dl=i(),qe=n("h2"),Zt=n("a"),Zr=n("span"),h(Nn.$$.fragment),U_=i(),ei=n("span"),J_=p("Seq2SeqLMOutput"),ul=i(),Oe=n("div"),h(zn.$$.fragment),G_=i(),ti=n("p"),K_=p("Base class for sequence-to-sequence language models outputs."),ll=i(),Se=n("h2"),eo=n("a"),oi=n("span"),h(En.$$.fragment),X_=i(),ni=n("span"),Z_=p("NextSentencePredictorOutput"),pl=i(),Fe=n("div"),h(Pn.$$.fragment),em=i(),si=n("p"),tm=p("Base class for outputs of models predicting if two sentences are consecutive or not."),cl=i(),Me=n("h2"),to=n("a"),ai=n("span"),h(Bn.$$.fragment),om=i(),ri=n("span"),nm=p("SequenceClassifierOutput"),hl=i(),ke=n("div"),h(Ln.$$.fragment),sm=i(),ii=n("p"),am=p("Base class for outputs of sentence classification models."),fl=i(),Ae=n("h2"),oo=n("a"),di=n("span"),h(jn.$$.fragment),rm=i(),ui=n("span"),im=p("Seq2SeqSequenceClassifierOutput"),_l=i(),Ce=n("div"),h(Wn.$$.fragment),dm=i(),li=n("p"),um=p("Base class for outputs of sequence-to-sequence sentence classification models."),ml=i(),Ne=n("h2"),no=n("a"),pi=n("span"),h(Dn.$$.fragment),lm=i(),ci=n("span"),pm=p("MultipleChoiceModelOutput"),gl=i(),ze=n("div"),h(Hn.$$.fragment),cm=i(),hi=n("p"),hm=p("Base class for outputs of multiple choice models."),vl=i(),Ee=n("h2"),so=n("a"),fi=n("span"),h(Qn.$$.fragment),fm=i(),_i=n("span"),_m=p("TokenClassifierOutput"),yl=i(),Pe=n("div"),h(In.$$.fragment),mm=i(),mi=n("p"),gm=p("Base class for outputs of token classification models."),Tl=i(),Be=n("h2"),ao=n("a"),gi=n("span"),h(Vn.$$.fragment),vm=i(),vi=n("span"),ym=p("QuestionAnsweringModelOutput"),wl=i(),Le=n("div"),h(Rn.$$.fragment),Tm=i(),yi=n("p"),wm=p("Base class for outputs of question answering models."),bl=i(),je=n("h2"),ro=n("a"),Ti=n("span"),h(Yn.$$.fragment),bm=i(),wi=n("span"),xm=p("Seq2SeqQuestionAnsweringModelOutput"),xl=i(),We=n("div"),h(Un.$$.fragment),$m=i(),bi=n("p"),qm=p("Base class for outputs of sequence-to-sequence question answering models."),$l=i(),De=n("h2"),io=n("a"),xi=n("span"),h(Jn.$$.fragment),Om=i(),$i=n("span"),Sm=p("TFBaseModelOutput"),ql=i(),He=n("div"),h(Gn.$$.fragment),Fm=i(),qi=n("p"),Mm=p("Base class for model\u2019s outputs, with potential hidden states and attentions."),Ol=i(),Qe=n("h2"),uo=n("a"),Oi=n("span"),h(Kn.$$.fragment),km=i(),Si=n("span"),Am=p("TFBaseModelOutputWithPooling"),Sl=i(),Ie=n("div"),h(Xn.$$.fragment),Cm=i(),Fi=n("p"),Nm=p("Base class for model\u2019s outputs that also contains a pooling of the last hidden states."),Fl=i(),Ve=n("h2"),lo=n("a"),Mi=n("span"),h(Zn.$$.fragment),zm=i(),ki=n("span"),Em=p("TFBaseModelOutputWithPoolingAndCrossAttentions"),Ml=i(),Re=n("div"),h(es.$$.fragment),Pm=i(),Ai=n("p"),Bm=p("Base class for model\u2019s outputs that also contains a pooling of the last hidden states."),kl=i(),Ye=n("h2"),po=n("a"),Ci=n("span"),h(ts.$$.fragment),Lm=i(),Ni=n("span"),jm=p("TFBaseModelOutputWithPast"),Al=i(),Ue=n("div"),h(os.$$.fragment),Wm=i(),zi=n("p"),Dm=p("Base class for model\u2019s outputs that may also contain a past key/values (to speed up sequential decoding)."),Cl=i(),Je=n("h2"),co=n("a"),Ei=n("span"),h(ns.$$.fragment),Hm=i(),Pi=n("span"),Qm=p("TFBaseModelOutputWithPastAndCrossAttentions"),Nl=i(),Ge=n("div"),h(ss.$$.fragment),Im=i(),Bi=n("p"),Vm=p("Base class for model\u2019s outputs that may also contain a past key/values (to speed up sequential decoding)."),zl=i(),Ke=n("h2"),ho=n("a"),Li=n("span"),h(as.$$.fragment),Rm=i(),ji=n("span"),Ym=p("TFSeq2SeqModelOutput"),El=i(),Xe=n("div"),h(rs.$$.fragment),Um=i(),Wi=n("p"),Jm=p(`Base class for model encoder\u2019s outputs that also contains : pre-computed hidden states that can speed up sequential
decoding.`),Pl=i(),Ze=n("h2"),fo=n("a"),Di=n("span"),h(is.$$.fragment),Gm=i(),Hi=n("span"),Km=p("TFCausalLMOutput"),Bl=i(),et=n("div"),h(ds.$$.fragment),Xm=i(),Qi=n("p"),Zm=p("Base class for causal language model (or autoregressive) outputs."),Ll=i(),tt=n("h2"),_o=n("a"),Ii=n("span"),h(us.$$.fragment),eg=i(),Vi=n("span"),tg=p("TFCausalLMOutputWithCrossAttentions"),jl=i(),ot=n("div"),h(ls.$$.fragment),og=i(),Ri=n("p"),ng=p("Base class for causal language model (or autoregressive) outputs."),Wl=i(),nt=n("h2"),mo=n("a"),Yi=n("span"),h(ps.$$.fragment),sg=i(),Ui=n("span"),ag=p("TFCausalLMOutputWithPast"),Dl=i(),st=n("div"),h(cs.$$.fragment),rg=i(),Ji=n("p"),ig=p("Base class for causal language model (or autoregressive) outputs."),Hl=i(),at=n("h2"),go=n("a"),Gi=n("span"),h(hs.$$.fragment),dg=i(),Ki=n("span"),ug=p("TFMaskedLMOutput"),Ql=i(),rt=n("div"),h(fs.$$.fragment),lg=i(),Xi=n("p"),pg=p("Base class for masked language models outputs."),Il=i(),it=n("h2"),vo=n("a"),Zi=n("span"),h(_s.$$.fragment),cg=i(),ed=n("span"),hg=p("TFSeq2SeqLMOutput"),Vl=i(),dt=n("div"),h(ms.$$.fragment),fg=i(),td=n("p"),_g=p("Base class for sequence-to-sequence language models outputs."),Rl=i(),ut=n("h2"),yo=n("a"),od=n("span"),h(gs.$$.fragment),mg=i(),nd=n("span"),gg=p("TFNextSentencePredictorOutput"),Yl=i(),lt=n("div"),h(vs.$$.fragment),vg=i(),sd=n("p"),yg=p("Base class for outputs of models predicting if two sentences are consecutive or not."),Ul=i(),pt=n("h2"),To=n("a"),ad=n("span"),h(ys.$$.fragment),Tg=i(),rd=n("span"),wg=p("TFSequenceClassifierOutput"),Jl=i(),ct=n("div"),h(Ts.$$.fragment),bg=i(),id=n("p"),xg=p("Base class for outputs of sentence classification models."),Gl=i(),ht=n("h2"),wo=n("a"),dd=n("span"),h(ws.$$.fragment),$g=i(),ud=n("span"),qg=p("TFSeq2SeqSequenceClassifierOutput"),Kl=i(),ft=n("div"),h(bs.$$.fragment),Og=i(),ld=n("p"),Sg=p("Base class for outputs of sequence-to-sequence sentence classification models."),Xl=i(),_t=n("h2"),bo=n("a"),pd=n("span"),h(xs.$$.fragment),Fg=i(),cd=n("span"),Mg=p("TFMultipleChoiceModelOutput"),Zl=i(),mt=n("div"),h($s.$$.fragment),kg=i(),hd=n("p"),Ag=p("Base class for outputs of multiple choice models."),ep=i(),gt=n("h2"),xo=n("a"),fd=n("span"),h(qs.$$.fragment),Cg=i(),_d=n("span"),Ng=p("TFTokenClassifierOutput"),tp=i(),vt=n("div"),h(Os.$$.fragment),zg=i(),md=n("p"),Eg=p("Base class for outputs of token classification models."),op=i(),yt=n("h2"),$o=n("a"),gd=n("span"),h(Ss.$$.fragment),Pg=i(),vd=n("span"),Bg=p("TFQuestionAnsweringModelOutput"),np=i(),Tt=n("div"),h(Fs.$$.fragment),Lg=i(),yd=n("p"),jg=p("Base class for outputs of question answering models."),sp=i(),wt=n("h2"),qo=n("a"),Td=n("span"),h(Ms.$$.fragment),Wg=i(),wd=n("span"),Dg=p("TFSeq2SeqQuestionAnsweringModelOutput"),ap=i(),bt=n("div"),h(ks.$$.fragment),Hg=i(),bd=n("p"),Qg=p("Base class for outputs of sequence-to-sequence question answering models."),rp=i(),xt=n("h2"),Oo=n("a"),xd=n("span"),h(As.$$.fragment),Ig=i(),$d=n("span"),Vg=p("FlaxBaseModelOutput"),ip=i(),N=n("div"),h(Cs.$$.fragment),Rg=i(),qd=n("p"),Yg=p("Base class for model\u2019s outputs, with potential hidden states and attentions."),Ug=i(),So=n("div"),h(Ns.$$.fragment),Jg=i(),Od=n("p"),Gg=p("\u201CReturns a new object replacing the specified fields with new values."),dp=i(),$t=n("h2"),Fo=n("a"),Sd=n("span"),h(zs.$$.fragment),Kg=i(),Fd=n("span"),Xg=p("FlaxBaseModelOutputWithPast"),up=i(),z=n("div"),h(Es.$$.fragment),Zg=i(),Md=n("p"),ev=p("Base class for model\u2019s outputs, with potential hidden states and attentions."),tv=i(),Mo=n("div"),h(Ps.$$.fragment),ov=i(),kd=n("p"),nv=p("\u201CReturns a new object replacing the specified fields with new values."),lp=i(),qt=n("h2"),ko=n("a"),Ad=n("span"),h(Bs.$$.fragment),sv=i(),Cd=n("span"),av=p("FlaxBaseModelOutputWithPooling"),pp=i(),E=n("div"),h(Ls.$$.fragment),rv=i(),Nd=n("p"),iv=p("Base class for model\u2019s outputs that also contains a pooling of the last hidden states."),dv=i(),Ao=n("div"),h(js.$$.fragment),uv=i(),zd=n("p"),lv=p("\u201CReturns a new object replacing the specified fields with new values."),cp=i(),Ot=n("h2"),Co=n("a"),Ed=n("span"),h(Ws.$$.fragment),pv=i(),Pd=n("span"),cv=p("FlaxBaseModelOutputWithPastAndCrossAttentions"),hp=i(),P=n("div"),h(Ds.$$.fragment),hv=i(),Bd=n("p"),fv=p("Base class for model\u2019s outputs that may also contain a past key/values (to speed up sequential decoding)."),_v=i(),No=n("div"),h(Hs.$$.fragment),mv=i(),Ld=n("p"),gv=p("\u201CReturns a new object replacing the specified fields with new values."),fp=i(),St=n("h2"),zo=n("a"),jd=n("span"),h(Qs.$$.fragment),vv=i(),Wd=n("span"),yv=p("FlaxSeq2SeqModelOutput"),_p=i(),B=n("div"),h(Is.$$.fragment),Tv=i(),Dd=n("p"),wv=p(`Base class for model encoder\u2019s outputs that also contains : pre-computed hidden states that can speed up sequential
decoding.`),bv=i(),Eo=n("div"),h(Vs.$$.fragment),xv=i(),Hd=n("p"),$v=p("\u201CReturns a new object replacing the specified fields with new values."),mp=i(),Ft=n("h2"),Po=n("a"),Qd=n("span"),h(Rs.$$.fragment),qv=i(),Id=n("span"),Ov=p("FlaxCausalLMOutputWithCrossAttentions"),gp=i(),L=n("div"),h(Ys.$$.fragment),Sv=i(),Vd=n("p"),Fv=p("Base class for causal language model (or autoregressive) outputs."),Mv=i(),Bo=n("div"),h(Us.$$.fragment),kv=i(),Rd=n("p"),Av=p("\u201CReturns a new object replacing the specified fields with new values."),vp=i(),Mt=n("h2"),Lo=n("a"),Yd=n("span"),h(Js.$$.fragment),Cv=i(),Ud=n("span"),Nv=p("FlaxMaskedLMOutput"),yp=i(),j=n("div"),h(Gs.$$.fragment),zv=i(),Jd=n("p"),Ev=p("Base class for masked language models outputs."),Pv=i(),jo=n("div"),h(Ks.$$.fragment),Bv=i(),Gd=n("p"),Lv=p("\u201CReturns a new object replacing the specified fields with new values."),Tp=i(),kt=n("h2"),Wo=n("a"),Kd=n("span"),h(Xs.$$.fragment),jv=i(),Xd=n("span"),Wv=p("FlaxSeq2SeqLMOutput"),wp=i(),W=n("div"),h(Zs.$$.fragment),Dv=i(),Zd=n("p"),Hv=p("Base class for sequence-to-sequence language models outputs."),Qv=i(),Do=n("div"),h(ea.$$.fragment),Iv=i(),eu=n("p"),Vv=p("\u201CReturns a new object replacing the specified fields with new values."),bp=i(),At=n("h2"),Ho=n("a"),tu=n("span"),h(ta.$$.fragment),Rv=i(),ou=n("span"),Yv=p("FlaxNextSentencePredictorOutput"),xp=i(),D=n("div"),h(oa.$$.fragment),Uv=i(),nu=n("p"),Jv=p("Base class for outputs of models predicting if two sentences are consecutive or not."),Gv=i(),Qo=n("div"),h(na.$$.fragment),Kv=i(),su=n("p"),Xv=p("\u201CReturns a new object replacing the specified fields with new values."),$p=i(),Ct=n("h2"),Io=n("a"),au=n("span"),h(sa.$$.fragment),Zv=i(),ru=n("span"),ey=p("FlaxSequenceClassifierOutput"),qp=i(),H=n("div"),h(aa.$$.fragment),ty=i(),iu=n("p"),oy=p("Base class for outputs of sentence classification models."),ny=i(),Vo=n("div"),h(ra.$$.fragment),sy=i(),du=n("p"),ay=p("\u201CReturns a new object replacing the specified fields with new values."),Op=i(),Nt=n("h2"),Ro=n("a"),uu=n("span"),h(ia.$$.fragment),ry=i(),lu=n("span"),iy=p("FlaxSeq2SeqSequenceClassifierOutput"),Sp=i(),Q=n("div"),h(da.$$.fragment),dy=i(),pu=n("p"),uy=p("Base class for outputs of sequence-to-sequence sentence classification models."),ly=i(),Yo=n("div"),h(ua.$$.fragment),py=i(),cu=n("p"),cy=p("\u201CReturns a new object replacing the specified fields with new values."),Fp=i(),zt=n("h2"),Uo=n("a"),hu=n("span"),h(la.$$.fragment),hy=i(),fu=n("span"),fy=p("FlaxMultipleChoiceModelOutput"),Mp=i(),I=n("div"),h(pa.$$.fragment),_y=i(),_u=n("p"),my=p("Base class for outputs of multiple choice models."),gy=i(),Jo=n("div"),h(ca.$$.fragment),vy=i(),mu=n("p"),yy=p("\u201CReturns a new object replacing the specified fields with new values."),kp=i(),Et=n("h2"),Go=n("a"),gu=n("span"),h(ha.$$.fragment),Ty=i(),vu=n("span"),wy=p("FlaxTokenClassifierOutput"),Ap=i(),V=n("div"),h(fa.$$.fragment),by=i(),yu=n("p"),xy=p("Base class for outputs of token classification models."),$y=i(),Ko=n("div"),h(_a.$$.fragment),qy=i(),Tu=n("p"),Oy=p("\u201CReturns a new object replacing the specified fields with new values."),Cp=i(),Pt=n("h2"),Xo=n("a"),wu=n("span"),h(ma.$$.fragment),Sy=i(),bu=n("span"),Fy=p("FlaxQuestionAnsweringModelOutput"),Np=i(),R=n("div"),h(ga.$$.fragment),My=i(),xu=n("p"),ky=p("Base class for outputs of question answering models."),Ay=i(),Zo=n("div"),h(va.$$.fragment),Cy=i(),$u=n("p"),Ny=p("\u201CReturns a new object replacing the specified fields with new values."),zp=i(),Bt=n("h2"),en=n("a"),qu=n("span"),h(ya.$$.fragment),zy=i(),Ou=n("span"),Ey=p("FlaxSeq2SeqQuestionAnsweringModelOutput"),Ep=i(),Y=n("div"),h(Ta.$$.fragment),Py=i(),Su=n("p"),By=p("Base class for outputs of sequence-to-sequence question answering models."),Ly=i(),tn=n("div"),h(wa.$$.fragment),jy=i(),Fu=n("p"),Wy=p("\u201CReturns a new object replacing the specified fields with new values."),this.h()},l(e){const u=Eb('[data-svelte="svelte-1phssyn"]',document.head);x=s(u,"META",{name:!0,content:!0}),u.forEach(t),U=d(e),$=s(e,"H1",{class:!0});var ba=a($);q=s(ba,"A",{id:!0,class:!0,href:!0});var Dy=a(q);X=s(Dy,"SPAN",{});var Hy=a(X);f(O.$$.fragment,Hy),Hy.forEach(t),Dy.forEach(t),nn=d(ba),Z=s(ba,"SPAN",{});var Qy=a(Z);ee=c(Qy,"Model outputs"),Qy.forEach(t),ba.forEach(t),k=d(e),C=s(e,"P",{});var Bp=a(C);xa=c(Bp,"All models have outputs that are instances of subclasses of "),$a=s(Bp,"A",{href:!0});var Iy=a($a);Lh=c(Iy,"ModelOutput"),Iy.forEach(t),jh=c(Bp,`. Those are
data structures containing all the information returned by the model, but that can also be used as tuples or
dictionaries.`),Bp.forEach(t),Mu=d(e),qa=s(e,"P",{});var Vy=a(qa);Wh=c(Vy,"Let\u2019s see of this looks on an example:"),Vy.forEach(t),ku=d(e),f(sn.$$.fragment,e),Au=d(e),w=s(e,"P",{});var b=a(w);Dh=c(b,"The "),Va=s(b,"CODE",{});var Ry=a(Va);Hh=c(Ry,"outputs"),Ry.forEach(t),Qh=c(b," object is a "),Oa=s(b,"A",{href:!0});var Yy=a(Oa);Ih=c(Yy,"SequenceClassifierOutput"),Yy.forEach(t),Vh=c(b,`, as we can see in the
documentation of that class below, it means it has an optional `),Ra=s(b,"CODE",{});var Uy=a(Ra);Rh=c(Uy,"loss"),Uy.forEach(t),Yh=c(b,", a "),Ya=s(b,"CODE",{});var Jy=a(Ya);Uh=c(Jy,"logits"),Jy.forEach(t),Jh=c(b," an optional "),Ua=s(b,"CODE",{});var Gy=a(Ua);Gh=c(Gy,"hidden_states"),Gy.forEach(t),Kh=c(b,` and
an optional `),Ja=s(b,"CODE",{});var Ky=a(Ja);Xh=c(Ky,"attentions"),Ky.forEach(t),Zh=c(b," attribute. Here we have the "),Ga=s(b,"CODE",{});var Xy=a(Ga);ef=c(Xy,"loss"),Xy.forEach(t),tf=c(b," since we passed along "),Ka=s(b,"CODE",{});var Zy=a(Ka);of=c(Zy,"labels"),Zy.forEach(t),nf=c(b,`, but we don\u2019t have
`),Xa=s(b,"CODE",{});var eT=a(Xa);sf=c(eT,"hidden_states"),eT.forEach(t),af=c(b," and "),Za=s(b,"CODE",{});var tT=a(Za);rf=c(tT,"attentions"),tT.forEach(t),df=c(b," because we didn\u2019t pass "),er=s(b,"CODE",{});var oT=a(er);uf=c(oT,"output_hidden_states=True"),oT.forEach(t),lf=c(b,` or
`),tr=s(b,"CODE",{});var nT=a(tr);pf=c(nT,"output_attentions=True"),nT.forEach(t),cf=c(b,"."),b.forEach(t),Cu=d(e),S=s(e,"P",{});var J=a(S);hf=c(J,`You can access each attribute as you would usually do, and if that attribute has not been returned by the model, you
will get `),or=s(J,"CODE",{});var sT=a(or);ff=c(sT,"None"),sT.forEach(t),_f=c(J,". Here for instance "),nr=s(J,"CODE",{});var aT=a(nr);mf=c(aT,"outputs.loss"),aT.forEach(t),gf=c(J," is the loss computed by the model, and "),sr=s(J,"CODE",{});var rT=a(sr);vf=c(rT,"outputs.attentions"),rT.forEach(t),yf=c(J,` is
`),ar=s(J,"CODE",{});var iT=a(ar);Tf=c(iT,"None"),iT.forEach(t),wf=c(J,"."),J.forEach(t),Nu=d(e),F=s(e,"P",{});var G=a(F);bf=c(G,"When considering our "),rr=s(G,"CODE",{});var dT=a(rr);xf=c(dT,"outputs"),dT.forEach(t),$f=c(G," object as tuple, it only considers the attributes that don\u2019t have "),ir=s(G,"CODE",{});var uT=a(ir);qf=c(uT,"None"),uT.forEach(t),Of=c(G,` values.
Here for instance, it has two elements, `),dr=s(G,"CODE",{});var lT=a(dr);Sf=c(lT,"loss"),lT.forEach(t),Ff=c(G," then "),ur=s(G,"CODE",{});var pT=a(ur);Mf=c(pT,"logits"),pT.forEach(t),kf=c(G,", so"),G.forEach(t),zu=d(e),f(an.$$.fragment,e),Eu=d(e),Lt=s(e,"P",{});var Lp=a(Lt);Af=c(Lp,"will return the tuple "),lr=s(Lp,"CODE",{});var cT=a(lr);Cf=c(cT,"(outputs.loss, outputs.logits)"),cT.forEach(t),Nf=c(Lp," for instance."),Lp.forEach(t),Pu=d(e),M=s(e,"P",{});var K=a(M);zf=c(K,"When considering our "),pr=s(K,"CODE",{});var hT=a(pr);Ef=c(hT,"outputs"),hT.forEach(t),Pf=c(K," object as dictionary, it only considers the attributes that don\u2019t have "),cr=s(K,"CODE",{});var fT=a(cr);Bf=c(fT,"None"),fT.forEach(t),Lf=c(K,`
values. Here for instance, it has two keys that are `),hr=s(K,"CODE",{});var _T=a(hr);jf=c(_T,"loss"),_T.forEach(t),Wf=c(K," and "),fr=s(K,"CODE",{});var mT=a(fr);Df=c(mT,"logits"),mT.forEach(t),Hf=c(K,"."),K.forEach(t),Bu=d(e),Sa=s(e,"P",{});var gT=a(Sa);Qf=c(gT,`We document here the generic model outputs that are used by more than one model type. Specific output types are
documented on their corresponding model page.`),gT.forEach(t),Lu=d(e),te=s(e,"H2",{class:!0});var jp=a(te);jt=s(jp,"A",{id:!0,class:!0,href:!0});var vT=a(jt);_r=s(vT,"SPAN",{});var yT=a(_r);f(rn.$$.fragment,yT),yT.forEach(t),vT.forEach(t),If=d(jp),mr=s(jp,"SPAN",{});var TT=a(mr);Vf=c(TT,"ModelOutput"),TT.forEach(t),jp.forEach(t),ju=d(e),A=s(e,"DIV",{class:!0});var on=a(A);f(dn.$$.fragment,on),Rf=d(on),oe=s(on,"P",{});var Fa=a(oe);Yf=c(Fa,"Base class for all model outputs as dataclass. Has a "),gr=s(Fa,"CODE",{});var wT=a(gr);Uf=c(wT,"__getitem__"),wT.forEach(t),Jf=c(Fa,` that allows indexing by integer or slice (like a
tuple) or strings (like a dictionary) that will ignore the `),vr=s(Fa,"CODE",{});var bT=a(vr);Gf=c(bT,"None"),bT.forEach(t),Kf=c(Fa,` attributes. Otherwise behaves like a regular
python dictionary.`),Fa.forEach(t),Xf=d(on),f(Wt.$$.fragment,on),Zf=d(on),Dt=s(on,"DIV",{class:!0});var Wp=a(Dt);f(un.$$.fragment,Wp),e_=d(Wp),ln=s(Wp,"P",{});var Dp=a(ln);t_=c(Dp,"Convert self to a tuple containing all the attributes/keys that are not "),yr=s(Dp,"CODE",{});var xT=a(yr);o_=c(xT,"None"),xT.forEach(t),n_=c(Dp,"."),Dp.forEach(t),Wp.forEach(t),on.forEach(t),Wu=d(e),ne=s(e,"H2",{class:!0});var Hp=a(ne);Ht=s(Hp,"A",{id:!0,class:!0,href:!0});var $T=a(Ht);Tr=s($T,"SPAN",{});var qT=a(Tr);f(pn.$$.fragment,qT),qT.forEach(t),$T.forEach(t),s_=d(Hp),wr=s(Hp,"SPAN",{});var OT=a(wr);a_=c(OT,"BaseModelOutput"),OT.forEach(t),Hp.forEach(t),Du=d(e),se=s(e,"DIV",{class:!0});var Qp=a(se);f(cn.$$.fragment,Qp),r_=d(Qp),br=s(Qp,"P",{});var ST=a(br);i_=c(ST,"Base class for model\u2019s outputs, with potential hidden states and attentions."),ST.forEach(t),Qp.forEach(t),Hu=d(e),ae=s(e,"H2",{class:!0});var Ip=a(ae);Qt=s(Ip,"A",{id:!0,class:!0,href:!0});var FT=a(Qt);xr=s(FT,"SPAN",{});var MT=a(xr);f(hn.$$.fragment,MT),MT.forEach(t),FT.forEach(t),d_=d(Ip),$r=s(Ip,"SPAN",{});var kT=a($r);u_=c(kT,"BaseModelOutputWithPooling"),kT.forEach(t),Ip.forEach(t),Qu=d(e),re=s(e,"DIV",{class:!0});var Vp=a(re);f(fn.$$.fragment,Vp),l_=d(Vp),qr=s(Vp,"P",{});var AT=a(qr);p_=c(AT,"Base class for model\u2019s outputs that also contains a pooling of the last hidden states."),AT.forEach(t),Vp.forEach(t),Iu=d(e),ie=s(e,"H2",{class:!0});var Rp=a(ie);It=s(Rp,"A",{id:!0,class:!0,href:!0});var CT=a(It);Or=s(CT,"SPAN",{});var NT=a(Or);f(_n.$$.fragment,NT),NT.forEach(t),CT.forEach(t),c_=d(Rp),Sr=s(Rp,"SPAN",{});var zT=a(Sr);h_=c(zT,"BaseModelOutputWithCrossAttentions"),zT.forEach(t),Rp.forEach(t),Vu=d(e),de=s(e,"DIV",{class:!0});var Yp=a(de);f(mn.$$.fragment,Yp),f_=d(Yp),Fr=s(Yp,"P",{});var ET=a(Fr);__=c(ET,"Base class for model\u2019s outputs, with potential hidden states and attentions."),ET.forEach(t),Yp.forEach(t),Ru=d(e),ue=s(e,"H2",{class:!0});var Up=a(ue);Vt=s(Up,"A",{id:!0,class:!0,href:!0});var PT=a(Vt);Mr=s(PT,"SPAN",{});var BT=a(Mr);f(gn.$$.fragment,BT),BT.forEach(t),PT.forEach(t),m_=d(Up),kr=s(Up,"SPAN",{});var LT=a(kr);g_=c(LT,"BaseModelOutputWithPoolingAndCrossAttentions"),LT.forEach(t),Up.forEach(t),Yu=d(e),le=s(e,"DIV",{class:!0});var Jp=a(le);f(vn.$$.fragment,Jp),v_=d(Jp),Ar=s(Jp,"P",{});var jT=a(Ar);y_=c(jT,"Base class for model\u2019s outputs that also contains a pooling of the last hidden states."),jT.forEach(t),Jp.forEach(t),Uu=d(e),pe=s(e,"H2",{class:!0});var Gp=a(pe);Rt=s(Gp,"A",{id:!0,class:!0,href:!0});var WT=a(Rt);Cr=s(WT,"SPAN",{});var DT=a(Cr);f(yn.$$.fragment,DT),DT.forEach(t),WT.forEach(t),T_=d(Gp),Nr=s(Gp,"SPAN",{});var HT=a(Nr);w_=c(HT,"BaseModelOutputWithPast"),HT.forEach(t),Gp.forEach(t),Ju=d(e),ce=s(e,"DIV",{class:!0});var Kp=a(ce);f(Tn.$$.fragment,Kp),b_=d(Kp),zr=s(Kp,"P",{});var QT=a(zr);x_=c(QT,"Base class for model\u2019s outputs that may also contain a past key/values (to speed up sequential decoding)."),QT.forEach(t),Kp.forEach(t),Gu=d(e),he=s(e,"H2",{class:!0});var Xp=a(he);Yt=s(Xp,"A",{id:!0,class:!0,href:!0});var IT=a(Yt);Er=s(IT,"SPAN",{});var VT=a(Er);f(wn.$$.fragment,VT),VT.forEach(t),IT.forEach(t),$_=d(Xp),Pr=s(Xp,"SPAN",{});var RT=a(Pr);q_=c(RT,"BaseModelOutputWithPastAndCrossAttentions"),RT.forEach(t),Xp.forEach(t),Ku=d(e),fe=s(e,"DIV",{class:!0});var Zp=a(fe);f(bn.$$.fragment,Zp),O_=d(Zp),Br=s(Zp,"P",{});var YT=a(Br);S_=c(YT,"Base class for model\u2019s outputs that may also contain a past key/values (to speed up sequential decoding)."),YT.forEach(t),Zp.forEach(t),Xu=d(e),_e=s(e,"H2",{class:!0});var ec=a(_e);Ut=s(ec,"A",{id:!0,class:!0,href:!0});var UT=a(Ut);Lr=s(UT,"SPAN",{});var JT=a(Lr);f(xn.$$.fragment,JT),JT.forEach(t),UT.forEach(t),F_=d(ec),jr=s(ec,"SPAN",{});var GT=a(jr);M_=c(GT,"Seq2SeqModelOutput"),GT.forEach(t),ec.forEach(t),Zu=d(e),me=s(e,"DIV",{class:!0});var tc=a(me);f($n.$$.fragment,tc),k_=d(tc),Wr=s(tc,"P",{});var KT=a(Wr);A_=c(KT,`Base class for model encoder\u2019s outputs that also contains : pre-computed hidden states that can speed up sequential
decoding.`),KT.forEach(t),tc.forEach(t),el=d(e),ge=s(e,"H2",{class:!0});var oc=a(ge);Jt=s(oc,"A",{id:!0,class:!0,href:!0});var XT=a(Jt);Dr=s(XT,"SPAN",{});var ZT=a(Dr);f(qn.$$.fragment,ZT),ZT.forEach(t),XT.forEach(t),C_=d(oc),Hr=s(oc,"SPAN",{});var ew=a(Hr);N_=c(ew,"CausalLMOutput"),ew.forEach(t),oc.forEach(t),tl=d(e),ve=s(e,"DIV",{class:!0});var nc=a(ve);f(On.$$.fragment,nc),z_=d(nc),Qr=s(nc,"P",{});var tw=a(Qr);E_=c(tw,"Base class for causal language model (or autoregressive) outputs."),tw.forEach(t),nc.forEach(t),ol=d(e),ye=s(e,"H2",{class:!0});var sc=a(ye);Gt=s(sc,"A",{id:!0,class:!0,href:!0});var ow=a(Gt);Ir=s(ow,"SPAN",{});var nw=a(Ir);f(Sn.$$.fragment,nw),nw.forEach(t),ow.forEach(t),P_=d(sc),Vr=s(sc,"SPAN",{});var sw=a(Vr);B_=c(sw,"CausalLMOutputWithCrossAttentions"),sw.forEach(t),sc.forEach(t),nl=d(e),Te=s(e,"DIV",{class:!0});var ac=a(Te);f(Fn.$$.fragment,ac),L_=d(ac),Rr=s(ac,"P",{});var aw=a(Rr);j_=c(aw,"Base class for causal language model (or autoregressive) outputs."),aw.forEach(t),ac.forEach(t),sl=d(e),we=s(e,"H2",{class:!0});var rc=a(we);Kt=s(rc,"A",{id:!0,class:!0,href:!0});var rw=a(Kt);Yr=s(rw,"SPAN",{});var iw=a(Yr);f(Mn.$$.fragment,iw),iw.forEach(t),rw.forEach(t),W_=d(rc),Ur=s(rc,"SPAN",{});var dw=a(Ur);D_=c(dw,"CausalLMOutputWithPast"),dw.forEach(t),rc.forEach(t),al=d(e),be=s(e,"DIV",{class:!0});var ic=a(be);f(kn.$$.fragment,ic),H_=d(ic),Jr=s(ic,"P",{});var uw=a(Jr);Q_=c(uw,"Base class for causal language model (or autoregressive) outputs."),uw.forEach(t),ic.forEach(t),rl=d(e),xe=s(e,"H2",{class:!0});var dc=a(xe);Xt=s(dc,"A",{id:!0,class:!0,href:!0});var lw=a(Xt);Gr=s(lw,"SPAN",{});var pw=a(Gr);f(An.$$.fragment,pw),pw.forEach(t),lw.forEach(t),I_=d(dc),Kr=s(dc,"SPAN",{});var cw=a(Kr);V_=c(cw,"MaskedLMOutput"),cw.forEach(t),dc.forEach(t),il=d(e),$e=s(e,"DIV",{class:!0});var uc=a($e);f(Cn.$$.fragment,uc),R_=d(uc),Xr=s(uc,"P",{});var hw=a(Xr);Y_=c(hw,"Base class for masked language models outputs."),hw.forEach(t),uc.forEach(t),dl=d(e),qe=s(e,"H2",{class:!0});var lc=a(qe);Zt=s(lc,"A",{id:!0,class:!0,href:!0});var fw=a(Zt);Zr=s(fw,"SPAN",{});var _w=a(Zr);f(Nn.$$.fragment,_w),_w.forEach(t),fw.forEach(t),U_=d(lc),ei=s(lc,"SPAN",{});var mw=a(ei);J_=c(mw,"Seq2SeqLMOutput"),mw.forEach(t),lc.forEach(t),ul=d(e),Oe=s(e,"DIV",{class:!0});var pc=a(Oe);f(zn.$$.fragment,pc),G_=d(pc),ti=s(pc,"P",{});var gw=a(ti);K_=c(gw,"Base class for sequence-to-sequence language models outputs."),gw.forEach(t),pc.forEach(t),ll=d(e),Se=s(e,"H2",{class:!0});var cc=a(Se);eo=s(cc,"A",{id:!0,class:!0,href:!0});var vw=a(eo);oi=s(vw,"SPAN",{});var yw=a(oi);f(En.$$.fragment,yw),yw.forEach(t),vw.forEach(t),X_=d(cc),ni=s(cc,"SPAN",{});var Tw=a(ni);Z_=c(Tw,"NextSentencePredictorOutput"),Tw.forEach(t),cc.forEach(t),pl=d(e),Fe=s(e,"DIV",{class:!0});var hc=a(Fe);f(Pn.$$.fragment,hc),em=d(hc),si=s(hc,"P",{});var ww=a(si);tm=c(ww,"Base class for outputs of models predicting if two sentences are consecutive or not."),ww.forEach(t),hc.forEach(t),cl=d(e),Me=s(e,"H2",{class:!0});var fc=a(Me);to=s(fc,"A",{id:!0,class:!0,href:!0});var bw=a(to);ai=s(bw,"SPAN",{});var xw=a(ai);f(Bn.$$.fragment,xw),xw.forEach(t),bw.forEach(t),om=d(fc),ri=s(fc,"SPAN",{});var $w=a(ri);nm=c($w,"SequenceClassifierOutput"),$w.forEach(t),fc.forEach(t),hl=d(e),ke=s(e,"DIV",{class:!0});var _c=a(ke);f(Ln.$$.fragment,_c),sm=d(_c),ii=s(_c,"P",{});var qw=a(ii);am=c(qw,"Base class for outputs of sentence classification models."),qw.forEach(t),_c.forEach(t),fl=d(e),Ae=s(e,"H2",{class:!0});var mc=a(Ae);oo=s(mc,"A",{id:!0,class:!0,href:!0});var Ow=a(oo);di=s(Ow,"SPAN",{});var Sw=a(di);f(jn.$$.fragment,Sw),Sw.forEach(t),Ow.forEach(t),rm=d(mc),ui=s(mc,"SPAN",{});var Fw=a(ui);im=c(Fw,"Seq2SeqSequenceClassifierOutput"),Fw.forEach(t),mc.forEach(t),_l=d(e),Ce=s(e,"DIV",{class:!0});var gc=a(Ce);f(Wn.$$.fragment,gc),dm=d(gc),li=s(gc,"P",{});var Mw=a(li);um=c(Mw,"Base class for outputs of sequence-to-sequence sentence classification models."),Mw.forEach(t),gc.forEach(t),ml=d(e),Ne=s(e,"H2",{class:!0});var vc=a(Ne);no=s(vc,"A",{id:!0,class:!0,href:!0});var kw=a(no);pi=s(kw,"SPAN",{});var Aw=a(pi);f(Dn.$$.fragment,Aw),Aw.forEach(t),kw.forEach(t),lm=d(vc),ci=s(vc,"SPAN",{});var Cw=a(ci);pm=c(Cw,"MultipleChoiceModelOutput"),Cw.forEach(t),vc.forEach(t),gl=d(e),ze=s(e,"DIV",{class:!0});var yc=a(ze);f(Hn.$$.fragment,yc),cm=d(yc),hi=s(yc,"P",{});var Nw=a(hi);hm=c(Nw,"Base class for outputs of multiple choice models."),Nw.forEach(t),yc.forEach(t),vl=d(e),Ee=s(e,"H2",{class:!0});var Tc=a(Ee);so=s(Tc,"A",{id:!0,class:!0,href:!0});var zw=a(so);fi=s(zw,"SPAN",{});var Ew=a(fi);f(Qn.$$.fragment,Ew),Ew.forEach(t),zw.forEach(t),fm=d(Tc),_i=s(Tc,"SPAN",{});var Pw=a(_i);_m=c(Pw,"TokenClassifierOutput"),Pw.forEach(t),Tc.forEach(t),yl=d(e),Pe=s(e,"DIV",{class:!0});var wc=a(Pe);f(In.$$.fragment,wc),mm=d(wc),mi=s(wc,"P",{});var Bw=a(mi);gm=c(Bw,"Base class for outputs of token classification models."),Bw.forEach(t),wc.forEach(t),Tl=d(e),Be=s(e,"H2",{class:!0});var bc=a(Be);ao=s(bc,"A",{id:!0,class:!0,href:!0});var Lw=a(ao);gi=s(Lw,"SPAN",{});var jw=a(gi);f(Vn.$$.fragment,jw),jw.forEach(t),Lw.forEach(t),vm=d(bc),vi=s(bc,"SPAN",{});var Ww=a(vi);ym=c(Ww,"QuestionAnsweringModelOutput"),Ww.forEach(t),bc.forEach(t),wl=d(e),Le=s(e,"DIV",{class:!0});var xc=a(Le);f(Rn.$$.fragment,xc),Tm=d(xc),yi=s(xc,"P",{});var Dw=a(yi);wm=c(Dw,"Base class for outputs of question answering models."),Dw.forEach(t),xc.forEach(t),bl=d(e),je=s(e,"H2",{class:!0});var $c=a(je);ro=s($c,"A",{id:!0,class:!0,href:!0});var Hw=a(ro);Ti=s(Hw,"SPAN",{});var Qw=a(Ti);f(Yn.$$.fragment,Qw),Qw.forEach(t),Hw.forEach(t),bm=d($c),wi=s($c,"SPAN",{});var Iw=a(wi);xm=c(Iw,"Seq2SeqQuestionAnsweringModelOutput"),Iw.forEach(t),$c.forEach(t),xl=d(e),We=s(e,"DIV",{class:!0});var qc=a(We);f(Un.$$.fragment,qc),$m=d(qc),bi=s(qc,"P",{});var Vw=a(bi);qm=c(Vw,"Base class for outputs of sequence-to-sequence question answering models."),Vw.forEach(t),qc.forEach(t),$l=d(e),De=s(e,"H2",{class:!0});var Oc=a(De);io=s(Oc,"A",{id:!0,class:!0,href:!0});var Rw=a(io);xi=s(Rw,"SPAN",{});var Yw=a(xi);f(Jn.$$.fragment,Yw),Yw.forEach(t),Rw.forEach(t),Om=d(Oc),$i=s(Oc,"SPAN",{});var Uw=a($i);Sm=c(Uw,"TFBaseModelOutput"),Uw.forEach(t),Oc.forEach(t),ql=d(e),He=s(e,"DIV",{class:!0});var Sc=a(He);f(Gn.$$.fragment,Sc),Fm=d(Sc),qi=s(Sc,"P",{});var Jw=a(qi);Mm=c(Jw,"Base class for model\u2019s outputs, with potential hidden states and attentions."),Jw.forEach(t),Sc.forEach(t),Ol=d(e),Qe=s(e,"H2",{class:!0});var Fc=a(Qe);uo=s(Fc,"A",{id:!0,class:!0,href:!0});var Gw=a(uo);Oi=s(Gw,"SPAN",{});var Kw=a(Oi);f(Kn.$$.fragment,Kw),Kw.forEach(t),Gw.forEach(t),km=d(Fc),Si=s(Fc,"SPAN",{});var Xw=a(Si);Am=c(Xw,"TFBaseModelOutputWithPooling"),Xw.forEach(t),Fc.forEach(t),Sl=d(e),Ie=s(e,"DIV",{class:!0});var Mc=a(Ie);f(Xn.$$.fragment,Mc),Cm=d(Mc),Fi=s(Mc,"P",{});var Zw=a(Fi);Nm=c(Zw,"Base class for model\u2019s outputs that also contains a pooling of the last hidden states."),Zw.forEach(t),Mc.forEach(t),Fl=d(e),Ve=s(e,"H2",{class:!0});var kc=a(Ve);lo=s(kc,"A",{id:!0,class:!0,href:!0});var e2=a(lo);Mi=s(e2,"SPAN",{});var t2=a(Mi);f(Zn.$$.fragment,t2),t2.forEach(t),e2.forEach(t),zm=d(kc),ki=s(kc,"SPAN",{});var o2=a(ki);Em=c(o2,"TFBaseModelOutputWithPoolingAndCrossAttentions"),o2.forEach(t),kc.forEach(t),Ml=d(e),Re=s(e,"DIV",{class:!0});var Ac=a(Re);f(es.$$.fragment,Ac),Pm=d(Ac),Ai=s(Ac,"P",{});var n2=a(Ai);Bm=c(n2,"Base class for model\u2019s outputs that also contains a pooling of the last hidden states."),n2.forEach(t),Ac.forEach(t),kl=d(e),Ye=s(e,"H2",{class:!0});var Cc=a(Ye);po=s(Cc,"A",{id:!0,class:!0,href:!0});var s2=a(po);Ci=s(s2,"SPAN",{});var a2=a(Ci);f(ts.$$.fragment,a2),a2.forEach(t),s2.forEach(t),Lm=d(Cc),Ni=s(Cc,"SPAN",{});var r2=a(Ni);jm=c(r2,"TFBaseModelOutputWithPast"),r2.forEach(t),Cc.forEach(t),Al=d(e),Ue=s(e,"DIV",{class:!0});var Nc=a(Ue);f(os.$$.fragment,Nc),Wm=d(Nc),zi=s(Nc,"P",{});var i2=a(zi);Dm=c(i2,"Base class for model\u2019s outputs that may also contain a past key/values (to speed up sequential decoding)."),i2.forEach(t),Nc.forEach(t),Cl=d(e),Je=s(e,"H2",{class:!0});var zc=a(Je);co=s(zc,"A",{id:!0,class:!0,href:!0});var d2=a(co);Ei=s(d2,"SPAN",{});var u2=a(Ei);f(ns.$$.fragment,u2),u2.forEach(t),d2.forEach(t),Hm=d(zc),Pi=s(zc,"SPAN",{});var l2=a(Pi);Qm=c(l2,"TFBaseModelOutputWithPastAndCrossAttentions"),l2.forEach(t),zc.forEach(t),Nl=d(e),Ge=s(e,"DIV",{class:!0});var Ec=a(Ge);f(ss.$$.fragment,Ec),Im=d(Ec),Bi=s(Ec,"P",{});var p2=a(Bi);Vm=c(p2,"Base class for model\u2019s outputs that may also contain a past key/values (to speed up sequential decoding)."),p2.forEach(t),Ec.forEach(t),zl=d(e),Ke=s(e,"H2",{class:!0});var Pc=a(Ke);ho=s(Pc,"A",{id:!0,class:!0,href:!0});var c2=a(ho);Li=s(c2,"SPAN",{});var h2=a(Li);f(as.$$.fragment,h2),h2.forEach(t),c2.forEach(t),Rm=d(Pc),ji=s(Pc,"SPAN",{});var f2=a(ji);Ym=c(f2,"TFSeq2SeqModelOutput"),f2.forEach(t),Pc.forEach(t),El=d(e),Xe=s(e,"DIV",{class:!0});var Bc=a(Xe);f(rs.$$.fragment,Bc),Um=d(Bc),Wi=s(Bc,"P",{});var _2=a(Wi);Jm=c(_2,`Base class for model encoder\u2019s outputs that also contains : pre-computed hidden states that can speed up sequential
decoding.`),_2.forEach(t),Bc.forEach(t),Pl=d(e),Ze=s(e,"H2",{class:!0});var Lc=a(Ze);fo=s(Lc,"A",{id:!0,class:!0,href:!0});var m2=a(fo);Di=s(m2,"SPAN",{});var g2=a(Di);f(is.$$.fragment,g2),g2.forEach(t),m2.forEach(t),Gm=d(Lc),Hi=s(Lc,"SPAN",{});var v2=a(Hi);Km=c(v2,"TFCausalLMOutput"),v2.forEach(t),Lc.forEach(t),Bl=d(e),et=s(e,"DIV",{class:!0});var jc=a(et);f(ds.$$.fragment,jc),Xm=d(jc),Qi=s(jc,"P",{});var y2=a(Qi);Zm=c(y2,"Base class for causal language model (or autoregressive) outputs."),y2.forEach(t),jc.forEach(t),Ll=d(e),tt=s(e,"H2",{class:!0});var Wc=a(tt);_o=s(Wc,"A",{id:!0,class:!0,href:!0});var T2=a(_o);Ii=s(T2,"SPAN",{});var w2=a(Ii);f(us.$$.fragment,w2),w2.forEach(t),T2.forEach(t),eg=d(Wc),Vi=s(Wc,"SPAN",{});var b2=a(Vi);tg=c(b2,"TFCausalLMOutputWithCrossAttentions"),b2.forEach(t),Wc.forEach(t),jl=d(e),ot=s(e,"DIV",{class:!0});var Dc=a(ot);f(ls.$$.fragment,Dc),og=d(Dc),Ri=s(Dc,"P",{});var x2=a(Ri);ng=c(x2,"Base class for causal language model (or autoregressive) outputs."),x2.forEach(t),Dc.forEach(t),Wl=d(e),nt=s(e,"H2",{class:!0});var Hc=a(nt);mo=s(Hc,"A",{id:!0,class:!0,href:!0});var $2=a(mo);Yi=s($2,"SPAN",{});var q2=a(Yi);f(ps.$$.fragment,q2),q2.forEach(t),$2.forEach(t),sg=d(Hc),Ui=s(Hc,"SPAN",{});var O2=a(Ui);ag=c(O2,"TFCausalLMOutputWithPast"),O2.forEach(t),Hc.forEach(t),Dl=d(e),st=s(e,"DIV",{class:!0});var Qc=a(st);f(cs.$$.fragment,Qc),rg=d(Qc),Ji=s(Qc,"P",{});var S2=a(Ji);ig=c(S2,"Base class for causal language model (or autoregressive) outputs."),S2.forEach(t),Qc.forEach(t),Hl=d(e),at=s(e,"H2",{class:!0});var Ic=a(at);go=s(Ic,"A",{id:!0,class:!0,href:!0});var F2=a(go);Gi=s(F2,"SPAN",{});var M2=a(Gi);f(hs.$$.fragment,M2),M2.forEach(t),F2.forEach(t),dg=d(Ic),Ki=s(Ic,"SPAN",{});var k2=a(Ki);ug=c(k2,"TFMaskedLMOutput"),k2.forEach(t),Ic.forEach(t),Ql=d(e),rt=s(e,"DIV",{class:!0});var Vc=a(rt);f(fs.$$.fragment,Vc),lg=d(Vc),Xi=s(Vc,"P",{});var A2=a(Xi);pg=c(A2,"Base class for masked language models outputs."),A2.forEach(t),Vc.forEach(t),Il=d(e),it=s(e,"H2",{class:!0});var Rc=a(it);vo=s(Rc,"A",{id:!0,class:!0,href:!0});var C2=a(vo);Zi=s(C2,"SPAN",{});var N2=a(Zi);f(_s.$$.fragment,N2),N2.forEach(t),C2.forEach(t),cg=d(Rc),ed=s(Rc,"SPAN",{});var z2=a(ed);hg=c(z2,"TFSeq2SeqLMOutput"),z2.forEach(t),Rc.forEach(t),Vl=d(e),dt=s(e,"DIV",{class:!0});var Yc=a(dt);f(ms.$$.fragment,Yc),fg=d(Yc),td=s(Yc,"P",{});var E2=a(td);_g=c(E2,"Base class for sequence-to-sequence language models outputs."),E2.forEach(t),Yc.forEach(t),Rl=d(e),ut=s(e,"H2",{class:!0});var Uc=a(ut);yo=s(Uc,"A",{id:!0,class:!0,href:!0});var P2=a(yo);od=s(P2,"SPAN",{});var B2=a(od);f(gs.$$.fragment,B2),B2.forEach(t),P2.forEach(t),mg=d(Uc),nd=s(Uc,"SPAN",{});var L2=a(nd);gg=c(L2,"TFNextSentencePredictorOutput"),L2.forEach(t),Uc.forEach(t),Yl=d(e),lt=s(e,"DIV",{class:!0});var Jc=a(lt);f(vs.$$.fragment,Jc),vg=d(Jc),sd=s(Jc,"P",{});var j2=a(sd);yg=c(j2,"Base class for outputs of models predicting if two sentences are consecutive or not."),j2.forEach(t),Jc.forEach(t),Ul=d(e),pt=s(e,"H2",{class:!0});var Gc=a(pt);To=s(Gc,"A",{id:!0,class:!0,href:!0});var W2=a(To);ad=s(W2,"SPAN",{});var D2=a(ad);f(ys.$$.fragment,D2),D2.forEach(t),W2.forEach(t),Tg=d(Gc),rd=s(Gc,"SPAN",{});var H2=a(rd);wg=c(H2,"TFSequenceClassifierOutput"),H2.forEach(t),Gc.forEach(t),Jl=d(e),ct=s(e,"DIV",{class:!0});var Kc=a(ct);f(Ts.$$.fragment,Kc),bg=d(Kc),id=s(Kc,"P",{});var Q2=a(id);xg=c(Q2,"Base class for outputs of sentence classification models."),Q2.forEach(t),Kc.forEach(t),Gl=d(e),ht=s(e,"H2",{class:!0});var Xc=a(ht);wo=s(Xc,"A",{id:!0,class:!0,href:!0});var I2=a(wo);dd=s(I2,"SPAN",{});var V2=a(dd);f(ws.$$.fragment,V2),V2.forEach(t),I2.forEach(t),$g=d(Xc),ud=s(Xc,"SPAN",{});var R2=a(ud);qg=c(R2,"TFSeq2SeqSequenceClassifierOutput"),R2.forEach(t),Xc.forEach(t),Kl=d(e),ft=s(e,"DIV",{class:!0});var Zc=a(ft);f(bs.$$.fragment,Zc),Og=d(Zc),ld=s(Zc,"P",{});var Y2=a(ld);Sg=c(Y2,"Base class for outputs of sequence-to-sequence sentence classification models."),Y2.forEach(t),Zc.forEach(t),Xl=d(e),_t=s(e,"H2",{class:!0});var eh=a(_t);bo=s(eh,"A",{id:!0,class:!0,href:!0});var U2=a(bo);pd=s(U2,"SPAN",{});var J2=a(pd);f(xs.$$.fragment,J2),J2.forEach(t),U2.forEach(t),Fg=d(eh),cd=s(eh,"SPAN",{});var G2=a(cd);Mg=c(G2,"TFMultipleChoiceModelOutput"),G2.forEach(t),eh.forEach(t),Zl=d(e),mt=s(e,"DIV",{class:!0});var th=a(mt);f($s.$$.fragment,th),kg=d(th),hd=s(th,"P",{});var K2=a(hd);Ag=c(K2,"Base class for outputs of multiple choice models."),K2.forEach(t),th.forEach(t),ep=d(e),gt=s(e,"H2",{class:!0});var oh=a(gt);xo=s(oh,"A",{id:!0,class:!0,href:!0});var X2=a(xo);fd=s(X2,"SPAN",{});var Z2=a(fd);f(qs.$$.fragment,Z2),Z2.forEach(t),X2.forEach(t),Cg=d(oh),_d=s(oh,"SPAN",{});var e1=a(_d);Ng=c(e1,"TFTokenClassifierOutput"),e1.forEach(t),oh.forEach(t),tp=d(e),vt=s(e,"DIV",{class:!0});var nh=a(vt);f(Os.$$.fragment,nh),zg=d(nh),md=s(nh,"P",{});var t1=a(md);Eg=c(t1,"Base class for outputs of token classification models."),t1.forEach(t),nh.forEach(t),op=d(e),yt=s(e,"H2",{class:!0});var sh=a(yt);$o=s(sh,"A",{id:!0,class:!0,href:!0});var o1=a($o);gd=s(o1,"SPAN",{});var n1=a(gd);f(Ss.$$.fragment,n1),n1.forEach(t),o1.forEach(t),Pg=d(sh),vd=s(sh,"SPAN",{});var s1=a(vd);Bg=c(s1,"TFQuestionAnsweringModelOutput"),s1.forEach(t),sh.forEach(t),np=d(e),Tt=s(e,"DIV",{class:!0});var ah=a(Tt);f(Fs.$$.fragment,ah),Lg=d(ah),yd=s(ah,"P",{});var a1=a(yd);jg=c(a1,"Base class for outputs of question answering models."),a1.forEach(t),ah.forEach(t),sp=d(e),wt=s(e,"H2",{class:!0});var rh=a(wt);qo=s(rh,"A",{id:!0,class:!0,href:!0});var r1=a(qo);Td=s(r1,"SPAN",{});var i1=a(Td);f(Ms.$$.fragment,i1),i1.forEach(t),r1.forEach(t),Wg=d(rh),wd=s(rh,"SPAN",{});var d1=a(wd);Dg=c(d1,"TFSeq2SeqQuestionAnsweringModelOutput"),d1.forEach(t),rh.forEach(t),ap=d(e),bt=s(e,"DIV",{class:!0});var ih=a(bt);f(ks.$$.fragment,ih),Hg=d(ih),bd=s(ih,"P",{});var u1=a(bd);Qg=c(u1,"Base class for outputs of sequence-to-sequence question answering models."),u1.forEach(t),ih.forEach(t),rp=d(e),xt=s(e,"H2",{class:!0});var dh=a(xt);Oo=s(dh,"A",{id:!0,class:!0,href:!0});var l1=a(Oo);xd=s(l1,"SPAN",{});var p1=a(xd);f(As.$$.fragment,p1),p1.forEach(t),l1.forEach(t),Ig=d(dh),$d=s(dh,"SPAN",{});var c1=a($d);Vg=c(c1,"FlaxBaseModelOutput"),c1.forEach(t),dh.forEach(t),ip=d(e),N=s(e,"DIV",{class:!0});var Ma=a(N);f(Cs.$$.fragment,Ma),Rg=d(Ma),qd=s(Ma,"P",{});var h1=a(qd);Yg=c(h1,"Base class for model\u2019s outputs, with potential hidden states and attentions."),h1.forEach(t),Ug=d(Ma),So=s(Ma,"DIV",{class:!0});var uh=a(So);f(Ns.$$.fragment,uh),Jg=d(uh),Od=s(uh,"P",{});var f1=a(Od);Gg=c(f1,"\u201CReturns a new object replacing the specified fields with new values."),f1.forEach(t),uh.forEach(t),Ma.forEach(t),dp=d(e),$t=s(e,"H2",{class:!0});var lh=a($t);Fo=s(lh,"A",{id:!0,class:!0,href:!0});var _1=a(Fo);Sd=s(_1,"SPAN",{});var m1=a(Sd);f(zs.$$.fragment,m1),m1.forEach(t),_1.forEach(t),Kg=d(lh),Fd=s(lh,"SPAN",{});var g1=a(Fd);Xg=c(g1,"FlaxBaseModelOutputWithPast"),g1.forEach(t),lh.forEach(t),up=d(e),z=s(e,"DIV",{class:!0});var ka=a(z);f(Es.$$.fragment,ka),Zg=d(ka),Md=s(ka,"P",{});var v1=a(Md);ev=c(v1,"Base class for model\u2019s outputs, with potential hidden states and attentions."),v1.forEach(t),tv=d(ka),Mo=s(ka,"DIV",{class:!0});var ph=a(Mo);f(Ps.$$.fragment,ph),ov=d(ph),kd=s(ph,"P",{});var y1=a(kd);nv=c(y1,"\u201CReturns a new object replacing the specified fields with new values."),y1.forEach(t),ph.forEach(t),ka.forEach(t),lp=d(e),qt=s(e,"H2",{class:!0});var ch=a(qt);ko=s(ch,"A",{id:!0,class:!0,href:!0});var T1=a(ko);Ad=s(T1,"SPAN",{});var w1=a(Ad);f(Bs.$$.fragment,w1),w1.forEach(t),T1.forEach(t),sv=d(ch),Cd=s(ch,"SPAN",{});var b1=a(Cd);av=c(b1,"FlaxBaseModelOutputWithPooling"),b1.forEach(t),ch.forEach(t),pp=d(e),E=s(e,"DIV",{class:!0});var Aa=a(E);f(Ls.$$.fragment,Aa),rv=d(Aa),Nd=s(Aa,"P",{});var x1=a(Nd);iv=c(x1,"Base class for model\u2019s outputs that also contains a pooling of the last hidden states."),x1.forEach(t),dv=d(Aa),Ao=s(Aa,"DIV",{class:!0});var hh=a(Ao);f(js.$$.fragment,hh),uv=d(hh),zd=s(hh,"P",{});var $1=a(zd);lv=c($1,"\u201CReturns a new object replacing the specified fields with new values."),$1.forEach(t),hh.forEach(t),Aa.forEach(t),cp=d(e),Ot=s(e,"H2",{class:!0});var fh=a(Ot);Co=s(fh,"A",{id:!0,class:!0,href:!0});var q1=a(Co);Ed=s(q1,"SPAN",{});var O1=a(Ed);f(Ws.$$.fragment,O1),O1.forEach(t),q1.forEach(t),pv=d(fh),Pd=s(fh,"SPAN",{});var S1=a(Pd);cv=c(S1,"FlaxBaseModelOutputWithPastAndCrossAttentions"),S1.forEach(t),fh.forEach(t),hp=d(e),P=s(e,"DIV",{class:!0});var Ca=a(P);f(Ds.$$.fragment,Ca),hv=d(Ca),Bd=s(Ca,"P",{});var F1=a(Bd);fv=c(F1,"Base class for model\u2019s outputs that may also contain a past key/values (to speed up sequential decoding)."),F1.forEach(t),_v=d(Ca),No=s(Ca,"DIV",{class:!0});var _h=a(No);f(Hs.$$.fragment,_h),mv=d(_h),Ld=s(_h,"P",{});var M1=a(Ld);gv=c(M1,"\u201CReturns a new object replacing the specified fields with new values."),M1.forEach(t),_h.forEach(t),Ca.forEach(t),fp=d(e),St=s(e,"H2",{class:!0});var mh=a(St);zo=s(mh,"A",{id:!0,class:!0,href:!0});var k1=a(zo);jd=s(k1,"SPAN",{});var A1=a(jd);f(Qs.$$.fragment,A1),A1.forEach(t),k1.forEach(t),vv=d(mh),Wd=s(mh,"SPAN",{});var C1=a(Wd);yv=c(C1,"FlaxSeq2SeqModelOutput"),C1.forEach(t),mh.forEach(t),_p=d(e),B=s(e,"DIV",{class:!0});var Na=a(B);f(Is.$$.fragment,Na),Tv=d(Na),Dd=s(Na,"P",{});var N1=a(Dd);wv=c(N1,`Base class for model encoder\u2019s outputs that also contains : pre-computed hidden states that can speed up sequential
decoding.`),N1.forEach(t),bv=d(Na),Eo=s(Na,"DIV",{class:!0});var gh=a(Eo);f(Vs.$$.fragment,gh),xv=d(gh),Hd=s(gh,"P",{});var z1=a(Hd);$v=c(z1,"\u201CReturns a new object replacing the specified fields with new values."),z1.forEach(t),gh.forEach(t),Na.forEach(t),mp=d(e),Ft=s(e,"H2",{class:!0});var vh=a(Ft);Po=s(vh,"A",{id:!0,class:!0,href:!0});var E1=a(Po);Qd=s(E1,"SPAN",{});var P1=a(Qd);f(Rs.$$.fragment,P1),P1.forEach(t),E1.forEach(t),qv=d(vh),Id=s(vh,"SPAN",{});var B1=a(Id);Ov=c(B1,"FlaxCausalLMOutputWithCrossAttentions"),B1.forEach(t),vh.forEach(t),gp=d(e),L=s(e,"DIV",{class:!0});var za=a(L);f(Ys.$$.fragment,za),Sv=d(za),Vd=s(za,"P",{});var L1=a(Vd);Fv=c(L1,"Base class for causal language model (or autoregressive) outputs."),L1.forEach(t),Mv=d(za),Bo=s(za,"DIV",{class:!0});var yh=a(Bo);f(Us.$$.fragment,yh),kv=d(yh),Rd=s(yh,"P",{});var j1=a(Rd);Av=c(j1,"\u201CReturns a new object replacing the specified fields with new values."),j1.forEach(t),yh.forEach(t),za.forEach(t),vp=d(e),Mt=s(e,"H2",{class:!0});var Th=a(Mt);Lo=s(Th,"A",{id:!0,class:!0,href:!0});var W1=a(Lo);Yd=s(W1,"SPAN",{});var D1=a(Yd);f(Js.$$.fragment,D1),D1.forEach(t),W1.forEach(t),Cv=d(Th),Ud=s(Th,"SPAN",{});var H1=a(Ud);Nv=c(H1,"FlaxMaskedLMOutput"),H1.forEach(t),Th.forEach(t),yp=d(e),j=s(e,"DIV",{class:!0});var Ea=a(j);f(Gs.$$.fragment,Ea),zv=d(Ea),Jd=s(Ea,"P",{});var Q1=a(Jd);Ev=c(Q1,"Base class for masked language models outputs."),Q1.forEach(t),Pv=d(Ea),jo=s(Ea,"DIV",{class:!0});var wh=a(jo);f(Ks.$$.fragment,wh),Bv=d(wh),Gd=s(wh,"P",{});var I1=a(Gd);Lv=c(I1,"\u201CReturns a new object replacing the specified fields with new values."),I1.forEach(t),wh.forEach(t),Ea.forEach(t),Tp=d(e),kt=s(e,"H2",{class:!0});var bh=a(kt);Wo=s(bh,"A",{id:!0,class:!0,href:!0});var V1=a(Wo);Kd=s(V1,"SPAN",{});var R1=a(Kd);f(Xs.$$.fragment,R1),R1.forEach(t),V1.forEach(t),jv=d(bh),Xd=s(bh,"SPAN",{});var Y1=a(Xd);Wv=c(Y1,"FlaxSeq2SeqLMOutput"),Y1.forEach(t),bh.forEach(t),wp=d(e),W=s(e,"DIV",{class:!0});var Pa=a(W);f(Zs.$$.fragment,Pa),Dv=d(Pa),Zd=s(Pa,"P",{});var U1=a(Zd);Hv=c(U1,"Base class for sequence-to-sequence language models outputs."),U1.forEach(t),Qv=d(Pa),Do=s(Pa,"DIV",{class:!0});var xh=a(Do);f(ea.$$.fragment,xh),Iv=d(xh),eu=s(xh,"P",{});var J1=a(eu);Vv=c(J1,"\u201CReturns a new object replacing the specified fields with new values."),J1.forEach(t),xh.forEach(t),Pa.forEach(t),bp=d(e),At=s(e,"H2",{class:!0});var $h=a(At);Ho=s($h,"A",{id:!0,class:!0,href:!0});var G1=a(Ho);tu=s(G1,"SPAN",{});var K1=a(tu);f(ta.$$.fragment,K1),K1.forEach(t),G1.forEach(t),Rv=d($h),ou=s($h,"SPAN",{});var X1=a(ou);Yv=c(X1,"FlaxNextSentencePredictorOutput"),X1.forEach(t),$h.forEach(t),xp=d(e),D=s(e,"DIV",{class:!0});var Ba=a(D);f(oa.$$.fragment,Ba),Uv=d(Ba),nu=s(Ba,"P",{});var Z1=a(nu);Jv=c(Z1,"Base class for outputs of models predicting if two sentences are consecutive or not."),Z1.forEach(t),Gv=d(Ba),Qo=s(Ba,"DIV",{class:!0});var qh=a(Qo);f(na.$$.fragment,qh),Kv=d(qh),su=s(qh,"P",{});var eb=a(su);Xv=c(eb,"\u201CReturns a new object replacing the specified fields with new values."),eb.forEach(t),qh.forEach(t),Ba.forEach(t),$p=d(e),Ct=s(e,"H2",{class:!0});var Oh=a(Ct);Io=s(Oh,"A",{id:!0,class:!0,href:!0});var tb=a(Io);au=s(tb,"SPAN",{});var ob=a(au);f(sa.$$.fragment,ob),ob.forEach(t),tb.forEach(t),Zv=d(Oh),ru=s(Oh,"SPAN",{});var nb=a(ru);ey=c(nb,"FlaxSequenceClassifierOutput"),nb.forEach(t),Oh.forEach(t),qp=d(e),H=s(e,"DIV",{class:!0});var La=a(H);f(aa.$$.fragment,La),ty=d(La),iu=s(La,"P",{});var sb=a(iu);oy=c(sb,"Base class for outputs of sentence classification models."),sb.forEach(t),ny=d(La),Vo=s(La,"DIV",{class:!0});var Sh=a(Vo);f(ra.$$.fragment,Sh),sy=d(Sh),du=s(Sh,"P",{});var ab=a(du);ay=c(ab,"\u201CReturns a new object replacing the specified fields with new values."),ab.forEach(t),Sh.forEach(t),La.forEach(t),Op=d(e),Nt=s(e,"H2",{class:!0});var Fh=a(Nt);Ro=s(Fh,"A",{id:!0,class:!0,href:!0});var rb=a(Ro);uu=s(rb,"SPAN",{});var ib=a(uu);f(ia.$$.fragment,ib),ib.forEach(t),rb.forEach(t),ry=d(Fh),lu=s(Fh,"SPAN",{});var db=a(lu);iy=c(db,"FlaxSeq2SeqSequenceClassifierOutput"),db.forEach(t),Fh.forEach(t),Sp=d(e),Q=s(e,"DIV",{class:!0});var ja=a(Q);f(da.$$.fragment,ja),dy=d(ja),pu=s(ja,"P",{});var ub=a(pu);uy=c(ub,"Base class for outputs of sequence-to-sequence sentence classification models."),ub.forEach(t),ly=d(ja),Yo=s(ja,"DIV",{class:!0});var Mh=a(Yo);f(ua.$$.fragment,Mh),py=d(Mh),cu=s(Mh,"P",{});var lb=a(cu);cy=c(lb,"\u201CReturns a new object replacing the specified fields with new values."),lb.forEach(t),Mh.forEach(t),ja.forEach(t),Fp=d(e),zt=s(e,"H2",{class:!0});var kh=a(zt);Uo=s(kh,"A",{id:!0,class:!0,href:!0});var pb=a(Uo);hu=s(pb,"SPAN",{});var cb=a(hu);f(la.$$.fragment,cb),cb.forEach(t),pb.forEach(t),hy=d(kh),fu=s(kh,"SPAN",{});var hb=a(fu);fy=c(hb,"FlaxMultipleChoiceModelOutput"),hb.forEach(t),kh.forEach(t),Mp=d(e),I=s(e,"DIV",{class:!0});var Wa=a(I);f(pa.$$.fragment,Wa),_y=d(Wa),_u=s(Wa,"P",{});var fb=a(_u);my=c(fb,"Base class for outputs of multiple choice models."),fb.forEach(t),gy=d(Wa),Jo=s(Wa,"DIV",{class:!0});var Ah=a(Jo);f(ca.$$.fragment,Ah),vy=d(Ah),mu=s(Ah,"P",{});var _b=a(mu);yy=c(_b,"\u201CReturns a new object replacing the specified fields with new values."),_b.forEach(t),Ah.forEach(t),Wa.forEach(t),kp=d(e),Et=s(e,"H2",{class:!0});var Ch=a(Et);Go=s(Ch,"A",{id:!0,class:!0,href:!0});var mb=a(Go);gu=s(mb,"SPAN",{});var gb=a(gu);f(ha.$$.fragment,gb),gb.forEach(t),mb.forEach(t),Ty=d(Ch),vu=s(Ch,"SPAN",{});var vb=a(vu);wy=c(vb,"FlaxTokenClassifierOutput"),vb.forEach(t),Ch.forEach(t),Ap=d(e),V=s(e,"DIV",{class:!0});var Da=a(V);f(fa.$$.fragment,Da),by=d(Da),yu=s(Da,"P",{});var yb=a(yu);xy=c(yb,"Base class for outputs of token classification models."),yb.forEach(t),$y=d(Da),Ko=s(Da,"DIV",{class:!0});var Nh=a(Ko);f(_a.$$.fragment,Nh),qy=d(Nh),Tu=s(Nh,"P",{});var Tb=a(Tu);Oy=c(Tb,"\u201CReturns a new object replacing the specified fields with new values."),Tb.forEach(t),Nh.forEach(t),Da.forEach(t),Cp=d(e),Pt=s(e,"H2",{class:!0});var zh=a(Pt);Xo=s(zh,"A",{id:!0,class:!0,href:!0});var wb=a(Xo);wu=s(wb,"SPAN",{});var bb=a(wu);f(ma.$$.fragment,bb),bb.forEach(t),wb.forEach(t),Sy=d(zh),bu=s(zh,"SPAN",{});var xb=a(bu);Fy=c(xb,"FlaxQuestionAnsweringModelOutput"),xb.forEach(t),zh.forEach(t),Np=d(e),R=s(e,"DIV",{class:!0});var Ha=a(R);f(ga.$$.fragment,Ha),My=d(Ha),xu=s(Ha,"P",{});var $b=a(xu);ky=c($b,"Base class for outputs of question answering models."),$b.forEach(t),Ay=d(Ha),Zo=s(Ha,"DIV",{class:!0});var Eh=a(Zo);f(va.$$.fragment,Eh),Cy=d(Eh),$u=s(Eh,"P",{});var qb=a($u);Ny=c(qb,"\u201CReturns a new object replacing the specified fields with new values."),qb.forEach(t),Eh.forEach(t),Ha.forEach(t),zp=d(e),Bt=s(e,"H2",{class:!0});var Ph=a(Bt);en=s(Ph,"A",{id:!0,class:!0,href:!0});var Ob=a(en);qu=s(Ob,"SPAN",{});var Sb=a(qu);f(ya.$$.fragment,Sb),Sb.forEach(t),Ob.forEach(t),zy=d(Ph),Ou=s(Ph,"SPAN",{});var Fb=a(Ou);Ey=c(Fb,"FlaxSeq2SeqQuestionAnsweringModelOutput"),Fb.forEach(t),Ph.forEach(t),Ep=d(e),Y=s(e,"DIV",{class:!0});var Qa=a(Y);f(Ta.$$.fragment,Qa),Py=d(Qa),Su=s(Qa,"P",{});var Mb=a(Su);By=c(Mb,"Base class for outputs of sequence-to-sequence question answering models."),Mb.forEach(t),Ly=d(Qa),tn=s(Qa,"DIV",{class:!0});var Bh=a(tn);f(wa.$$.fragment,Bh),jy=d(Bh),Fu=s(Bh,"P",{});var kb=a(Fu);Wy=c(kb,"\u201CReturns a new object replacing the specified fields with new values."),kb.forEach(t),Bh.forEach(t),Qa.forEach(t),this.h()},h(){r(x,"name","hf:doc:metadata"),r(x,"content",JSON.stringify(jb)),r(q,"id","model-outputs"),r(q,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(q,"href","#model-outputs"),r($,"class","relative group"),r($a,"href","/docs/transformers/pr_15839/en/main_classes/output#transformers.file_utils.ModelOutput"),r(Oa,"href","/docs/transformers/pr_15839/en/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput"),r(jt,"id","transformers.file_utils.ModelOutput"),r(jt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(jt,"href","#transformers.file_utils.ModelOutput"),r(te,"class","relative group"),r(Dt,"class","docstring"),r(A,"class","docstring"),r(Ht,"id","transformers.modeling_outputs.BaseModelOutput"),r(Ht,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Ht,"href","#transformers.modeling_outputs.BaseModelOutput"),r(ne,"class","relative group"),r(se,"class","docstring"),r(Qt,"id","transformers.modeling_outputs.BaseModelOutputWithPooling"),r(Qt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Qt,"href","#transformers.modeling_outputs.BaseModelOutputWithPooling"),r(ae,"class","relative group"),r(re,"class","docstring"),r(It,"id","transformers.modeling_outputs.BaseModelOutputWithCrossAttentions"),r(It,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(It,"href","#transformers.modeling_outputs.BaseModelOutputWithCrossAttentions"),r(ie,"class","relative group"),r(de,"class","docstring"),r(Vt,"id","transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions"),r(Vt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Vt,"href","#transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions"),r(ue,"class","relative group"),r(le,"class","docstring"),r(Rt,"id","transformers.modeling_outputs.BaseModelOutputWithPast"),r(Rt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Rt,"href","#transformers.modeling_outputs.BaseModelOutputWithPast"),r(pe,"class","relative group"),r(ce,"class","docstring"),r(Yt,"id","transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions"),r(Yt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Yt,"href","#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions"),r(he,"class","relative group"),r(fe,"class","docstring"),r(Ut,"id","transformers.modeling_outputs.Seq2SeqModelOutput"),r(Ut,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Ut,"href","#transformers.modeling_outputs.Seq2SeqModelOutput"),r(_e,"class","relative group"),r(me,"class","docstring"),r(Jt,"id","transformers.modeling_outputs.CausalLMOutput"),r(Jt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Jt,"href","#transformers.modeling_outputs.CausalLMOutput"),r(ge,"class","relative group"),r(ve,"class","docstring"),r(Gt,"id","transformers.modeling_outputs.CausalLMOutputWithCrossAttentions"),r(Gt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Gt,"href","#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions"),r(ye,"class","relative group"),r(Te,"class","docstring"),r(Kt,"id","transformers.modeling_outputs.CausalLMOutputWithPast"),r(Kt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Kt,"href","#transformers.modeling_outputs.CausalLMOutputWithPast"),r(we,"class","relative group"),r(be,"class","docstring"),r(Xt,"id","transformers.modeling_outputs.MaskedLMOutput"),r(Xt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Xt,"href","#transformers.modeling_outputs.MaskedLMOutput"),r(xe,"class","relative group"),r($e,"class","docstring"),r(Zt,"id","transformers.modeling_outputs.Seq2SeqLMOutput"),r(Zt,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Zt,"href","#transformers.modeling_outputs.Seq2SeqLMOutput"),r(qe,"class","relative group"),r(Oe,"class","docstring"),r(eo,"id","transformers.modeling_outputs.NextSentencePredictorOutput"),r(eo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(eo,"href","#transformers.modeling_outputs.NextSentencePredictorOutput"),r(Se,"class","relative group"),r(Fe,"class","docstring"),r(to,"id","transformers.modeling_outputs.SequenceClassifierOutput"),r(to,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(to,"href","#transformers.modeling_outputs.SequenceClassifierOutput"),r(Me,"class","relative group"),r(ke,"class","docstring"),r(oo,"id","transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput"),r(oo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(oo,"href","#transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput"),r(Ae,"class","relative group"),r(Ce,"class","docstring"),r(no,"id","transformers.modeling_outputs.MultipleChoiceModelOutput"),r(no,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(no,"href","#transformers.modeling_outputs.MultipleChoiceModelOutput"),r(Ne,"class","relative group"),r(ze,"class","docstring"),r(so,"id","transformers.modeling_outputs.TokenClassifierOutput"),r(so,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(so,"href","#transformers.modeling_outputs.TokenClassifierOutput"),r(Ee,"class","relative group"),r(Pe,"class","docstring"),r(ao,"id","transformers.modeling_outputs.QuestionAnsweringModelOutput"),r(ao,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(ao,"href","#transformers.modeling_outputs.QuestionAnsweringModelOutput"),r(Be,"class","relative group"),r(Le,"class","docstring"),r(ro,"id","transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput"),r(ro,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(ro,"href","#transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput"),r(je,"class","relative group"),r(We,"class","docstring"),r(io,"id","transformers.modeling_tf_outputs.TFBaseModelOutput"),r(io,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(io,"href","#transformers.modeling_tf_outputs.TFBaseModelOutput"),r(De,"class","relative group"),r(He,"class","docstring"),r(uo,"id","transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling"),r(uo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(uo,"href","#transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling"),r(Qe,"class","relative group"),r(Ie,"class","docstring"),r(lo,"id","transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions"),r(lo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(lo,"href","#transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions"),r(Ve,"class","relative group"),r(Re,"class","docstring"),r(po,"id","transformers.modeling_tf_outputs.TFBaseModelOutputWithPast"),r(po,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(po,"href","#transformers.modeling_tf_outputs.TFBaseModelOutputWithPast"),r(Ye,"class","relative group"),r(Ue,"class","docstring"),r(co,"id","transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions"),r(co,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(co,"href","#transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions"),r(Je,"class","relative group"),r(Ge,"class","docstring"),r(ho,"id","transformers.modeling_tf_outputs.TFSeq2SeqModelOutput"),r(ho,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(ho,"href","#transformers.modeling_tf_outputs.TFSeq2SeqModelOutput"),r(Ke,"class","relative group"),r(Xe,"class","docstring"),r(fo,"id","transformers.modeling_tf_outputs.TFCausalLMOutput"),r(fo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(fo,"href","#transformers.modeling_tf_outputs.TFCausalLMOutput"),r(Ze,"class","relative group"),r(et,"class","docstring"),r(_o,"id","transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions"),r(_o,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(_o,"href","#transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions"),r(tt,"class","relative group"),r(ot,"class","docstring"),r(mo,"id","transformers.modeling_tf_outputs.TFCausalLMOutputWithPast"),r(mo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(mo,"href","#transformers.modeling_tf_outputs.TFCausalLMOutputWithPast"),r(nt,"class","relative group"),r(st,"class","docstring"),r(go,"id","transformers.modeling_tf_outputs.TFMaskedLMOutput"),r(go,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(go,"href","#transformers.modeling_tf_outputs.TFMaskedLMOutput"),r(at,"class","relative group"),r(rt,"class","docstring"),r(vo,"id","transformers.modeling_tf_outputs.TFSeq2SeqLMOutput"),r(vo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(vo,"href","#transformers.modeling_tf_outputs.TFSeq2SeqLMOutput"),r(it,"class","relative group"),r(dt,"class","docstring"),r(yo,"id","transformers.modeling_tf_outputs.TFNextSentencePredictorOutput"),r(yo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(yo,"href","#transformers.modeling_tf_outputs.TFNextSentencePredictorOutput"),r(ut,"class","relative group"),r(lt,"class","docstring"),r(To,"id","transformers.modeling_tf_outputs.TFSequenceClassifierOutput"),r(To,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(To,"href","#transformers.modeling_tf_outputs.TFSequenceClassifierOutput"),r(pt,"class","relative group"),r(ct,"class","docstring"),r(wo,"id","transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput"),r(wo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(wo,"href","#transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput"),r(ht,"class","relative group"),r(ft,"class","docstring"),r(bo,"id","transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput"),r(bo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(bo,"href","#transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput"),r(_t,"class","relative group"),r(mt,"class","docstring"),r(xo,"id","transformers.modeling_tf_outputs.TFTokenClassifierOutput"),r(xo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(xo,"href","#transformers.modeling_tf_outputs.TFTokenClassifierOutput"),r(gt,"class","relative group"),r(vt,"class","docstring"),r($o,"id","transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput"),r($o,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r($o,"href","#transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput"),r(yt,"class","relative group"),r(Tt,"class","docstring"),r(qo,"id","transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput"),r(qo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(qo,"href","#transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput"),r(wt,"class","relative group"),r(bt,"class","docstring"),r(Oo,"id","transformers.modeling_flax_outputs.FlaxBaseModelOutput"),r(Oo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Oo,"href","#transformers.modeling_flax_outputs.FlaxBaseModelOutput"),r(xt,"class","relative group"),r(So,"class","docstring"),r(N,"class","docstring"),r(Fo,"id","transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast"),r(Fo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Fo,"href","#transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast"),r($t,"class","relative group"),r(Mo,"class","docstring"),r(z,"class","docstring"),r(ko,"id","transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling"),r(ko,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(ko,"href","#transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling"),r(qt,"class","relative group"),r(Ao,"class","docstring"),r(E,"class","docstring"),r(Co,"id","transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions"),r(Co,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Co,"href","#transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions"),r(Ot,"class","relative group"),r(No,"class","docstring"),r(P,"class","docstring"),r(zo,"id","transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput"),r(zo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(zo,"href","#transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput"),r(St,"class","relative group"),r(Eo,"class","docstring"),r(B,"class","docstring"),r(Po,"id","transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions"),r(Po,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Po,"href","#transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions"),r(Ft,"class","relative group"),r(Bo,"class","docstring"),r(L,"class","docstring"),r(Lo,"id","transformers.modeling_flax_outputs.FlaxMaskedLMOutput"),r(Lo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Lo,"href","#transformers.modeling_flax_outputs.FlaxMaskedLMOutput"),r(Mt,"class","relative group"),r(jo,"class","docstring"),r(j,"class","docstring"),r(Wo,"id","transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput"),r(Wo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Wo,"href","#transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput"),r(kt,"class","relative group"),r(Do,"class","docstring"),r(W,"class","docstring"),r(Ho,"id","transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput"),r(Ho,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Ho,"href","#transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput"),r(At,"class","relative group"),r(Qo,"class","docstring"),r(D,"class","docstring"),r(Io,"id","transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput"),r(Io,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Io,"href","#transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput"),r(Ct,"class","relative group"),r(Vo,"class","docstring"),r(H,"class","docstring"),r(Ro,"id","transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput"),r(Ro,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Ro,"href","#transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput"),r(Nt,"class","relative group"),r(Yo,"class","docstring"),r(Q,"class","docstring"),r(Uo,"id","transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput"),r(Uo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Uo,"href","#transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput"),r(zt,"class","relative group"),r(Jo,"class","docstring"),r(I,"class","docstring"),r(Go,"id","transformers.modeling_flax_outputs.FlaxTokenClassifierOutput"),r(Go,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Go,"href","#transformers.modeling_flax_outputs.FlaxTokenClassifierOutput"),r(Et,"class","relative group"),r(Ko,"class","docstring"),r(V,"class","docstring"),r(Xo,"id","transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput"),r(Xo,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(Xo,"href","#transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput"),r(Pt,"class","relative group"),r(Zo,"class","docstring"),r(R,"class","docstring"),r(en,"id","transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput"),r(en,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),r(en,"href","#transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput"),r(Bt,"class","relative group"),r(tn,"class","docstring"),r(Y,"class","docstring")},m(e,u){o(document.head,x),l(e,U,u),l(e,$,u),o($,q),o(q,X),_(O,X,null),o($,nn),o($,Z),o(Z,ee),l(e,k,u),l(e,C,u),o(C,xa),o(C,$a),o($a,Lh),o(C,jh),l(e,Mu,u),l(e,qa,u),o(qa,Wh),l(e,ku,u),_(sn,e,u),l(e,Au,u),l(e,w,u),o(w,Dh),o(w,Va),o(Va,Hh),o(w,Qh),o(w,Oa),o(Oa,Ih),o(w,Vh),o(w,Ra),o(Ra,Rh),o(w,Yh),o(w,Ya),o(Ya,Uh),o(w,Jh),o(w,Ua),o(Ua,Gh),o(w,Kh),o(w,Ja),o(Ja,Xh),o(w,Zh),o(w,Ga),o(Ga,ef),o(w,tf),o(w,Ka),o(Ka,of),o(w,nf),o(w,Xa),o(Xa,sf),o(w,af),o(w,Za),o(Za,rf),o(w,df),o(w,er),o(er,uf),o(w,lf),o(w,tr),o(tr,pf),o(w,cf),l(e,Cu,u),l(e,S,u),o(S,hf),o(S,or),o(or,ff),o(S,_f),o(S,nr),o(nr,mf),o(S,gf),o(S,sr),o(sr,vf),o(S,yf),o(S,ar),o(ar,Tf),o(S,wf),l(e,Nu,u),l(e,F,u),o(F,bf),o(F,rr),o(rr,xf),o(F,$f),o(F,ir),o(ir,qf),o(F,Of),o(F,dr),o(dr,Sf),o(F,Ff),o(F,ur),o(ur,Mf),o(F,kf),l(e,zu,u),_(an,e,u),l(e,Eu,u),l(e,Lt,u),o(Lt,Af),o(Lt,lr),o(lr,Cf),o(Lt,Nf),l(e,Pu,u),l(e,M,u),o(M,zf),o(M,pr),o(pr,Ef),o(M,Pf),o(M,cr),o(cr,Bf),o(M,Lf),o(M,hr),o(hr,jf),o(M,Wf),o(M,fr),o(fr,Df),o(M,Hf),l(e,Bu,u),l(e,Sa,u),o(Sa,Qf),l(e,Lu,u),l(e,te,u),o(te,jt),o(jt,_r),_(rn,_r,null),o(te,If),o(te,mr),o(mr,Vf),l(e,ju,u),l(e,A,u),_(dn,A,null),o(A,Rf),o(A,oe),o(oe,Yf),o(oe,gr),o(gr,Uf),o(oe,Jf),o(oe,vr),o(vr,Gf),o(oe,Kf),o(A,Xf),_(Wt,A,null),o(A,Zf),o(A,Dt),_(un,Dt,null),o(Dt,e_),o(Dt,ln),o(ln,t_),o(ln,yr),o(yr,o_),o(ln,n_),l(e,Wu,u),l(e,ne,u),o(ne,Ht),o(Ht,Tr),_(pn,Tr,null),o(ne,s_),o(ne,wr),o(wr,a_),l(e,Du,u),l(e,se,u),_(cn,se,null),o(se,r_),o(se,br),o(br,i_),l(e,Hu,u),l(e,ae,u),o(ae,Qt),o(Qt,xr),_(hn,xr,null),o(ae,d_),o(ae,$r),o($r,u_),l(e,Qu,u),l(e,re,u),_(fn,re,null),o(re,l_),o(re,qr),o(qr,p_),l(e,Iu,u),l(e,ie,u),o(ie,It),o(It,Or),_(_n,Or,null),o(ie,c_),o(ie,Sr),o(Sr,h_),l(e,Vu,u),l(e,de,u),_(mn,de,null),o(de,f_),o(de,Fr),o(Fr,__),l(e,Ru,u),l(e,ue,u),o(ue,Vt),o(Vt,Mr),_(gn,Mr,null),o(ue,m_),o(ue,kr),o(kr,g_),l(e,Yu,u),l(e,le,u),_(vn,le,null),o(le,v_),o(le,Ar),o(Ar,y_),l(e,Uu,u),l(e,pe,u),o(pe,Rt),o(Rt,Cr),_(yn,Cr,null),o(pe,T_),o(pe,Nr),o(Nr,w_),l(e,Ju,u),l(e,ce,u),_(Tn,ce,null),o(ce,b_),o(ce,zr),o(zr,x_),l(e,Gu,u),l(e,he,u),o(he,Yt),o(Yt,Er),_(wn,Er,null),o(he,$_),o(he,Pr),o(Pr,q_),l(e,Ku,u),l(e,fe,u),_(bn,fe,null),o(fe,O_),o(fe,Br),o(Br,S_),l(e,Xu,u),l(e,_e,u),o(_e,Ut),o(Ut,Lr),_(xn,Lr,null),o(_e,F_),o(_e,jr),o(jr,M_),l(e,Zu,u),l(e,me,u),_($n,me,null),o(me,k_),o(me,Wr),o(Wr,A_),l(e,el,u),l(e,ge,u),o(ge,Jt),o(Jt,Dr),_(qn,Dr,null),o(ge,C_),o(ge,Hr),o(Hr,N_),l(e,tl,u),l(e,ve,u),_(On,ve,null),o(ve,z_),o(ve,Qr),o(Qr,E_),l(e,ol,u),l(e,ye,u),o(ye,Gt),o(Gt,Ir),_(Sn,Ir,null),o(ye,P_),o(ye,Vr),o(Vr,B_),l(e,nl,u),l(e,Te,u),_(Fn,Te,null),o(Te,L_),o(Te,Rr),o(Rr,j_),l(e,sl,u),l(e,we,u),o(we,Kt),o(Kt,Yr),_(Mn,Yr,null),o(we,W_),o(we,Ur),o(Ur,D_),l(e,al,u),l(e,be,u),_(kn,be,null),o(be,H_),o(be,Jr),o(Jr,Q_),l(e,rl,u),l(e,xe,u),o(xe,Xt),o(Xt,Gr),_(An,Gr,null),o(xe,I_),o(xe,Kr),o(Kr,V_),l(e,il,u),l(e,$e,u),_(Cn,$e,null),o($e,R_),o($e,Xr),o(Xr,Y_),l(e,dl,u),l(e,qe,u),o(qe,Zt),o(Zt,Zr),_(Nn,Zr,null),o(qe,U_),o(qe,ei),o(ei,J_),l(e,ul,u),l(e,Oe,u),_(zn,Oe,null),o(Oe,G_),o(Oe,ti),o(ti,K_),l(e,ll,u),l(e,Se,u),o(Se,eo),o(eo,oi),_(En,oi,null),o(Se,X_),o(Se,ni),o(ni,Z_),l(e,pl,u),l(e,Fe,u),_(Pn,Fe,null),o(Fe,em),o(Fe,si),o(si,tm),l(e,cl,u),l(e,Me,u),o(Me,to),o(to,ai),_(Bn,ai,null),o(Me,om),o(Me,ri),o(ri,nm),l(e,hl,u),l(e,ke,u),_(Ln,ke,null),o(ke,sm),o(ke,ii),o(ii,am),l(e,fl,u),l(e,Ae,u),o(Ae,oo),o(oo,di),_(jn,di,null),o(Ae,rm),o(Ae,ui),o(ui,im),l(e,_l,u),l(e,Ce,u),_(Wn,Ce,null),o(Ce,dm),o(Ce,li),o(li,um),l(e,ml,u),l(e,Ne,u),o(Ne,no),o(no,pi),_(Dn,pi,null),o(Ne,lm),o(Ne,ci),o(ci,pm),l(e,gl,u),l(e,ze,u),_(Hn,ze,null),o(ze,cm),o(ze,hi),o(hi,hm),l(e,vl,u),l(e,Ee,u),o(Ee,so),o(so,fi),_(Qn,fi,null),o(Ee,fm),o(Ee,_i),o(_i,_m),l(e,yl,u),l(e,Pe,u),_(In,Pe,null),o(Pe,mm),o(Pe,mi),o(mi,gm),l(e,Tl,u),l(e,Be,u),o(Be,ao),o(ao,gi),_(Vn,gi,null),o(Be,vm),o(Be,vi),o(vi,ym),l(e,wl,u),l(e,Le,u),_(Rn,Le,null),o(Le,Tm),o(Le,yi),o(yi,wm),l(e,bl,u),l(e,je,u),o(je,ro),o(ro,Ti),_(Yn,Ti,null),o(je,bm),o(je,wi),o(wi,xm),l(e,xl,u),l(e,We,u),_(Un,We,null),o(We,$m),o(We,bi),o(bi,qm),l(e,$l,u),l(e,De,u),o(De,io),o(io,xi),_(Jn,xi,null),o(De,Om),o(De,$i),o($i,Sm),l(e,ql,u),l(e,He,u),_(Gn,He,null),o(He,Fm),o(He,qi),o(qi,Mm),l(e,Ol,u),l(e,Qe,u),o(Qe,uo),o(uo,Oi),_(Kn,Oi,null),o(Qe,km),o(Qe,Si),o(Si,Am),l(e,Sl,u),l(e,Ie,u),_(Xn,Ie,null),o(Ie,Cm),o(Ie,Fi),o(Fi,Nm),l(e,Fl,u),l(e,Ve,u),o(Ve,lo),o(lo,Mi),_(Zn,Mi,null),o(Ve,zm),o(Ve,ki),o(ki,Em),l(e,Ml,u),l(e,Re,u),_(es,Re,null),o(Re,Pm),o(Re,Ai),o(Ai,Bm),l(e,kl,u),l(e,Ye,u),o(Ye,po),o(po,Ci),_(ts,Ci,null),o(Ye,Lm),o(Ye,Ni),o(Ni,jm),l(e,Al,u),l(e,Ue,u),_(os,Ue,null),o(Ue,Wm),o(Ue,zi),o(zi,Dm),l(e,Cl,u),l(e,Je,u),o(Je,co),o(co,Ei),_(ns,Ei,null),o(Je,Hm),o(Je,Pi),o(Pi,Qm),l(e,Nl,u),l(e,Ge,u),_(ss,Ge,null),o(Ge,Im),o(Ge,Bi),o(Bi,Vm),l(e,zl,u),l(e,Ke,u),o(Ke,ho),o(ho,Li),_(as,Li,null),o(Ke,Rm),o(Ke,ji),o(ji,Ym),l(e,El,u),l(e,Xe,u),_(rs,Xe,null),o(Xe,Um),o(Xe,Wi),o(Wi,Jm),l(e,Pl,u),l(e,Ze,u),o(Ze,fo),o(fo,Di),_(is,Di,null),o(Ze,Gm),o(Ze,Hi),o(Hi,Km),l(e,Bl,u),l(e,et,u),_(ds,et,null),o(et,Xm),o(et,Qi),o(Qi,Zm),l(e,Ll,u),l(e,tt,u),o(tt,_o),o(_o,Ii),_(us,Ii,null),o(tt,eg),o(tt,Vi),o(Vi,tg),l(e,jl,u),l(e,ot,u),_(ls,ot,null),o(ot,og),o(ot,Ri),o(Ri,ng),l(e,Wl,u),l(e,nt,u),o(nt,mo),o(mo,Yi),_(ps,Yi,null),o(nt,sg),o(nt,Ui),o(Ui,ag),l(e,Dl,u),l(e,st,u),_(cs,st,null),o(st,rg),o(st,Ji),o(Ji,ig),l(e,Hl,u),l(e,at,u),o(at,go),o(go,Gi),_(hs,Gi,null),o(at,dg),o(at,Ki),o(Ki,ug),l(e,Ql,u),l(e,rt,u),_(fs,rt,null),o(rt,lg),o(rt,Xi),o(Xi,pg),l(e,Il,u),l(e,it,u),o(it,vo),o(vo,Zi),_(_s,Zi,null),o(it,cg),o(it,ed),o(ed,hg),l(e,Vl,u),l(e,dt,u),_(ms,dt,null),o(dt,fg),o(dt,td),o(td,_g),l(e,Rl,u),l(e,ut,u),o(ut,yo),o(yo,od),_(gs,od,null),o(ut,mg),o(ut,nd),o(nd,gg),l(e,Yl,u),l(e,lt,u),_(vs,lt,null),o(lt,vg),o(lt,sd),o(sd,yg),l(e,Ul,u),l(e,pt,u),o(pt,To),o(To,ad),_(ys,ad,null),o(pt,Tg),o(pt,rd),o(rd,wg),l(e,Jl,u),l(e,ct,u),_(Ts,ct,null),o(ct,bg),o(ct,id),o(id,xg),l(e,Gl,u),l(e,ht,u),o(ht,wo),o(wo,dd),_(ws,dd,null),o(ht,$g),o(ht,ud),o(ud,qg),l(e,Kl,u),l(e,ft,u),_(bs,ft,null),o(ft,Og),o(ft,ld),o(ld,Sg),l(e,Xl,u),l(e,_t,u),o(_t,bo),o(bo,pd),_(xs,pd,null),o(_t,Fg),o(_t,cd),o(cd,Mg),l(e,Zl,u),l(e,mt,u),_($s,mt,null),o(mt,kg),o(mt,hd),o(hd,Ag),l(e,ep,u),l(e,gt,u),o(gt,xo),o(xo,fd),_(qs,fd,null),o(gt,Cg),o(gt,_d),o(_d,Ng),l(e,tp,u),l(e,vt,u),_(Os,vt,null),o(vt,zg),o(vt,md),o(md,Eg),l(e,op,u),l(e,yt,u),o(yt,$o),o($o,gd),_(Ss,gd,null),o(yt,Pg),o(yt,vd),o(vd,Bg),l(e,np,u),l(e,Tt,u),_(Fs,Tt,null),o(Tt,Lg),o(Tt,yd),o(yd,jg),l(e,sp,u),l(e,wt,u),o(wt,qo),o(qo,Td),_(Ms,Td,null),o(wt,Wg),o(wt,wd),o(wd,Dg),l(e,ap,u),l(e,bt,u),_(ks,bt,null),o(bt,Hg),o(bt,bd),o(bd,Qg),l(e,rp,u),l(e,xt,u),o(xt,Oo),o(Oo,xd),_(As,xd,null),o(xt,Ig),o(xt,$d),o($d,Vg),l(e,ip,u),l(e,N,u),_(Cs,N,null),o(N,Rg),o(N,qd),o(qd,Yg),o(N,Ug),o(N,So),_(Ns,So,null),o(So,Jg),o(So,Od),o(Od,Gg),l(e,dp,u),l(e,$t,u),o($t,Fo),o(Fo,Sd),_(zs,Sd,null),o($t,Kg),o($t,Fd),o(Fd,Xg),l(e,up,u),l(e,z,u),_(Es,z,null),o(z,Zg),o(z,Md),o(Md,ev),o(z,tv),o(z,Mo),_(Ps,Mo,null),o(Mo,ov),o(Mo,kd),o(kd,nv),l(e,lp,u),l(e,qt,u),o(qt,ko),o(ko,Ad),_(Bs,Ad,null),o(qt,sv),o(qt,Cd),o(Cd,av),l(e,pp,u),l(e,E,u),_(Ls,E,null),o(E,rv),o(E,Nd),o(Nd,iv),o(E,dv),o(E,Ao),_(js,Ao,null),o(Ao,uv),o(Ao,zd),o(zd,lv),l(e,cp,u),l(e,Ot,u),o(Ot,Co),o(Co,Ed),_(Ws,Ed,null),o(Ot,pv),o(Ot,Pd),o(Pd,cv),l(e,hp,u),l(e,P,u),_(Ds,P,null),o(P,hv),o(P,Bd),o(Bd,fv),o(P,_v),o(P,No),_(Hs,No,null),o(No,mv),o(No,Ld),o(Ld,gv),l(e,fp,u),l(e,St,u),o(St,zo),o(zo,jd),_(Qs,jd,null),o(St,vv),o(St,Wd),o(Wd,yv),l(e,_p,u),l(e,B,u),_(Is,B,null),o(B,Tv),o(B,Dd),o(Dd,wv),o(B,bv),o(B,Eo),_(Vs,Eo,null),o(Eo,xv),o(Eo,Hd),o(Hd,$v),l(e,mp,u),l(e,Ft,u),o(Ft,Po),o(Po,Qd),_(Rs,Qd,null),o(Ft,qv),o(Ft,Id),o(Id,Ov),l(e,gp,u),l(e,L,u),_(Ys,L,null),o(L,Sv),o(L,Vd),o(Vd,Fv),o(L,Mv),o(L,Bo),_(Us,Bo,null),o(Bo,kv),o(Bo,Rd),o(Rd,Av),l(e,vp,u),l(e,Mt,u),o(Mt,Lo),o(Lo,Yd),_(Js,Yd,null),o(Mt,Cv),o(Mt,Ud),o(Ud,Nv),l(e,yp,u),l(e,j,u),_(Gs,j,null),o(j,zv),o(j,Jd),o(Jd,Ev),o(j,Pv),o(j,jo),_(Ks,jo,null),o(jo,Bv),o(jo,Gd),o(Gd,Lv),l(e,Tp,u),l(e,kt,u),o(kt,Wo),o(Wo,Kd),_(Xs,Kd,null),o(kt,jv),o(kt,Xd),o(Xd,Wv),l(e,wp,u),l(e,W,u),_(Zs,W,null),o(W,Dv),o(W,Zd),o(Zd,Hv),o(W,Qv),o(W,Do),_(ea,Do,null),o(Do,Iv),o(Do,eu),o(eu,Vv),l(e,bp,u),l(e,At,u),o(At,Ho),o(Ho,tu),_(ta,tu,null),o(At,Rv),o(At,ou),o(ou,Yv),l(e,xp,u),l(e,D,u),_(oa,D,null),o(D,Uv),o(D,nu),o(nu,Jv),o(D,Gv),o(D,Qo),_(na,Qo,null),o(Qo,Kv),o(Qo,su),o(su,Xv),l(e,$p,u),l(e,Ct,u),o(Ct,Io),o(Io,au),_(sa,au,null),o(Ct,Zv),o(Ct,ru),o(ru,ey),l(e,qp,u),l(e,H,u),_(aa,H,null),o(H,ty),o(H,iu),o(iu,oy),o(H,ny),o(H,Vo),_(ra,Vo,null),o(Vo,sy),o(Vo,du),o(du,ay),l(e,Op,u),l(e,Nt,u),o(Nt,Ro),o(Ro,uu),_(ia,uu,null),o(Nt,ry),o(Nt,lu),o(lu,iy),l(e,Sp,u),l(e,Q,u),_(da,Q,null),o(Q,dy),o(Q,pu),o(pu,uy),o(Q,ly),o(Q,Yo),_(ua,Yo,null),o(Yo,py),o(Yo,cu),o(cu,cy),l(e,Fp,u),l(e,zt,u),o(zt,Uo),o(Uo,hu),_(la,hu,null),o(zt,hy),o(zt,fu),o(fu,fy),l(e,Mp,u),l(e,I,u),_(pa,I,null),o(I,_y),o(I,_u),o(_u,my),o(I,gy),o(I,Jo),_(ca,Jo,null),o(Jo,vy),o(Jo,mu),o(mu,yy),l(e,kp,u),l(e,Et,u),o(Et,Go),o(Go,gu),_(ha,gu,null),o(Et,Ty),o(Et,vu),o(vu,wy),l(e,Ap,u),l(e,V,u),_(fa,V,null),o(V,by),o(V,yu),o(yu,xy),o(V,$y),o(V,Ko),_(_a,Ko,null),o(Ko,qy),o(Ko,Tu),o(Tu,Oy),l(e,Cp,u),l(e,Pt,u),o(Pt,Xo),o(Xo,wu),_(ma,wu,null),o(Pt,Sy),o(Pt,bu),o(bu,Fy),l(e,Np,u),l(e,R,u),_(ga,R,null),o(R,My),o(R,xu),o(xu,ky),o(R,Ay),o(R,Zo),_(va,Zo,null),o(Zo,Cy),o(Zo,$u),o($u,Ny),l(e,zp,u),l(e,Bt,u),o(Bt,en),o(en,qu),_(ya,qu,null),o(Bt,zy),o(Bt,Ou),o(Ou,Ey),l(e,Ep,u),l(e,Y,u),_(Ta,Y,null),o(Y,Py),o(Y,Su),o(Su,By),o(Y,Ly),o(Y,tn),_(wa,tn,null),o(tn,jy),o(tn,Fu),o(Fu,Wy),Pp=!0},p(e,[u]){const ba={};u&2&&(ba.$$scope={dirty:u,ctx:e}),Wt.$set(ba)},i(e){Pp||(m(O.$$.fragment,e),m(sn.$$.fragment,e),m(an.$$.fragment,e),m(rn.$$.fragment,e),m(dn.$$.fragment,e),m(Wt.$$.fragment,e),m(un.$$.fragment,e),m(pn.$$.fragment,e),m(cn.$$.fragment,e),m(hn.$$.fragment,e),m(fn.$$.fragment,e),m(_n.$$.fragment,e),m(mn.$$.fragment,e),m(gn.$$.fragment,e),m(vn.$$.fragment,e),m(yn.$$.fragment,e),m(Tn.$$.fragment,e),m(wn.$$.fragment,e),m(bn.$$.fragment,e),m(xn.$$.fragment,e),m($n.$$.fragment,e),m(qn.$$.fragment,e),m(On.$$.fragment,e),m(Sn.$$.fragment,e),m(Fn.$$.fragment,e),m(Mn.$$.fragment,e),m(kn.$$.fragment,e),m(An.$$.fragment,e),m(Cn.$$.fragment,e),m(Nn.$$.fragment,e),m(zn.$$.fragment,e),m(En.$$.fragment,e),m(Pn.$$.fragment,e),m(Bn.$$.fragment,e),m(Ln.$$.fragment,e),m(jn.$$.fragment,e),m(Wn.$$.fragment,e),m(Dn.$$.fragment,e),m(Hn.$$.fragment,e),m(Qn.$$.fragment,e),m(In.$$.fragment,e),m(Vn.$$.fragment,e),m(Rn.$$.fragment,e),m(Yn.$$.fragment,e),m(Un.$$.fragment,e),m(Jn.$$.fragment,e),m(Gn.$$.fragment,e),m(Kn.$$.fragment,e),m(Xn.$$.fragment,e),m(Zn.$$.fragment,e),m(es.$$.fragment,e),m(ts.$$.fragment,e),m(os.$$.fragment,e),m(ns.$$.fragment,e),m(ss.$$.fragment,e),m(as.$$.fragment,e),m(rs.$$.fragment,e),m(is.$$.fragment,e),m(ds.$$.fragment,e),m(us.$$.fragment,e),m(ls.$$.fragment,e),m(ps.$$.fragment,e),m(cs.$$.fragment,e),m(hs.$$.fragment,e),m(fs.$$.fragment,e),m(_s.$$.fragment,e),m(ms.$$.fragment,e),m(gs.$$.fragment,e),m(vs.$$.fragment,e),m(ys.$$.fragment,e),m(Ts.$$.fragment,e),m(ws.$$.fragment,e),m(bs.$$.fragment,e),m(xs.$$.fragment,e),m($s.$$.fragment,e),m(qs.$$.fragment,e),m(Os.$$.fragment,e),m(Ss.$$.fragment,e),m(Fs.$$.fragment,e),m(Ms.$$.fragment,e),m(ks.$$.fragment,e),m(As.$$.fragment,e),m(Cs.$$.fragment,e),m(Ns.$$.fragment,e),m(zs.$$.fragment,e),m(Es.$$.fragment,e),m(Ps.$$.fragment,e),m(Bs.$$.fragment,e),m(Ls.$$.fragment,e),m(js.$$.fragment,e),m(Ws.$$.fragment,e),m(Ds.$$.fragment,e),m(Hs.$$.fragment,e),m(Qs.$$.fragment,e),m(Is.$$.fragment,e),m(Vs.$$.fragment,e),m(Rs.$$.fragment,e),m(Ys.$$.fragment,e),m(Us.$$.fragment,e),m(Js.$$.fragment,e),m(Gs.$$.fragment,e),m(Ks.$$.fragment,e),m(Xs.$$.fragment,e),m(Zs.$$.fragment,e),m(ea.$$.fragment,e),m(ta.$$.fragment,e),m(oa.$$.fragment,e),m(na.$$.fragment,e),m(sa.$$.fragment,e),m(aa.$$.fragment,e),m(ra.$$.fragment,e),m(ia.$$.fragment,e),m(da.$$.fragment,e),m(ua.$$.fragment,e),m(la.$$.fragment,e),m(pa.$$.fragment,e),m(ca.$$.fragment,e),m(ha.$$.fragment,e),m(fa.$$.fragment,e),m(_a.$$.fragment,e),m(ma.$$.fragment,e),m(ga.$$.fragment,e),m(va.$$.fragment,e),m(ya.$$.fragment,e),m(Ta.$$.fragment,e),m(wa.$$.fragment,e),Pp=!0)},o(e){g(O.$$.fragment,e),g(sn.$$.fragment,e),g(an.$$.fragment,e),g(rn.$$.fragment,e),g(dn.$$.fragment,e),g(Wt.$$.fragment,e),g(un.$$.fragment,e),g(pn.$$.fragment,e),g(cn.$$.fragment,e),g(hn.$$.fragment,e),g(fn.$$.fragment,e),g(_n.$$.fragment,e),g(mn.$$.fragment,e),g(gn.$$.fragment,e),g(vn.$$.fragment,e),g(yn.$$.fragment,e),g(Tn.$$.fragment,e),g(wn.$$.fragment,e),g(bn.$$.fragment,e),g(xn.$$.fragment,e),g($n.$$.fragment,e),g(qn.$$.fragment,e),g(On.$$.fragment,e),g(Sn.$$.fragment,e),g(Fn.$$.fragment,e),g(Mn.$$.fragment,e),g(kn.$$.fragment,e),g(An.$$.fragment,e),g(Cn.$$.fragment,e),g(Nn.$$.fragment,e),g(zn.$$.fragment,e),g(En.$$.fragment,e),g(Pn.$$.fragment,e),g(Bn.$$.fragment,e),g(Ln.$$.fragment,e),g(jn.$$.fragment,e),g(Wn.$$.fragment,e),g(Dn.$$.fragment,e),g(Hn.$$.fragment,e),g(Qn.$$.fragment,e),g(In.$$.fragment,e),g(Vn.$$.fragment,e),g(Rn.$$.fragment,e),g(Yn.$$.fragment,e),g(Un.$$.fragment,e),g(Jn.$$.fragment,e),g(Gn.$$.fragment,e),g(Kn.$$.fragment,e),g(Xn.$$.fragment,e),g(Zn.$$.fragment,e),g(es.$$.fragment,e),g(ts.$$.fragment,e),g(os.$$.fragment,e),g(ns.$$.fragment,e),g(ss.$$.fragment,e),g(as.$$.fragment,e),g(rs.$$.fragment,e),g(is.$$.fragment,e),g(ds.$$.fragment,e),g(us.$$.fragment,e),g(ls.$$.fragment,e),g(ps.$$.fragment,e),g(cs.$$.fragment,e),g(hs.$$.fragment,e),g(fs.$$.fragment,e),g(_s.$$.fragment,e),g(ms.$$.fragment,e),g(gs.$$.fragment,e),g(vs.$$.fragment,e),g(ys.$$.fragment,e),g(Ts.$$.fragment,e),g(ws.$$.fragment,e),g(bs.$$.fragment,e),g(xs.$$.fragment,e),g($s.$$.fragment,e),g(qs.$$.fragment,e),g(Os.$$.fragment,e),g(Ss.$$.fragment,e),g(Fs.$$.fragment,e),g(Ms.$$.fragment,e),g(ks.$$.fragment,e),g(As.$$.fragment,e),g(Cs.$$.fragment,e),g(Ns.$$.fragment,e),g(zs.$$.fragment,e),g(Es.$$.fragment,e),g(Ps.$$.fragment,e),g(Bs.$$.fragment,e),g(Ls.$$.fragment,e),g(js.$$.fragment,e),g(Ws.$$.fragment,e),g(Ds.$$.fragment,e),g(Hs.$$.fragment,e),g(Qs.$$.fragment,e),g(Is.$$.fragment,e),g(Vs.$$.fragment,e),g(Rs.$$.fragment,e),g(Ys.$$.fragment,e),g(Us.$$.fragment,e),g(Js.$$.fragment,e),g(Gs.$$.fragment,e),g(Ks.$$.fragment,e),g(Xs.$$.fragment,e),g(Zs.$$.fragment,e),g(ea.$$.fragment,e),g(ta.$$.fragment,e),g(oa.$$.fragment,e),g(na.$$.fragment,e),g(sa.$$.fragment,e),g(aa.$$.fragment,e),g(ra.$$.fragment,e),g(ia.$$.fragment,e),g(da.$$.fragment,e),g(ua.$$.fragment,e),g(la.$$.fragment,e),g(pa.$$.fragment,e),g(ca.$$.fragment,e),g(ha.$$.fragment,e),g(fa.$$.fragment,e),g(_a.$$.fragment,e),g(ma.$$.fragment,e),g(ga.$$.fragment,e),g(va.$$.fragment,e),g(ya.$$.fragment,e),g(Ta.$$.fragment,e),g(wa.$$.fragment,e),Pp=!1},d(e){t(x),e&&t(U),e&&t($),v(O),e&&t(k),e&&t(C),e&&t(Mu),e&&t(qa),e&&t(ku),v(sn,e),e&&t(Au),e&&t(w),e&&t(Cu),e&&t(S),e&&t(Nu),e&&t(F),e&&t(zu),v(an,e),e&&t(Eu),e&&t(Lt),e&&t(Pu),e&&t(M),e&&t(Bu),e&&t(Sa),e&&t(Lu),e&&t(te),v(rn),e&&t(ju),e&&t(A),v(dn),v(Wt),v(un),e&&t(Wu),e&&t(ne),v(pn),e&&t(Du),e&&t(se),v(cn),e&&t(Hu),e&&t(ae),v(hn),e&&t(Qu),e&&t(re),v(fn),e&&t(Iu),e&&t(ie),v(_n),e&&t(Vu),e&&t(de),v(mn),e&&t(Ru),e&&t(ue),v(gn),e&&t(Yu),e&&t(le),v(vn),e&&t(Uu),e&&t(pe),v(yn),e&&t(Ju),e&&t(ce),v(Tn),e&&t(Gu),e&&t(he),v(wn),e&&t(Ku),e&&t(fe),v(bn),e&&t(Xu),e&&t(_e),v(xn),e&&t(Zu),e&&t(me),v($n),e&&t(el),e&&t(ge),v(qn),e&&t(tl),e&&t(ve),v(On),e&&t(ol),e&&t(ye),v(Sn),e&&t(nl),e&&t(Te),v(Fn),e&&t(sl),e&&t(we),v(Mn),e&&t(al),e&&t(be),v(kn),e&&t(rl),e&&t(xe),v(An),e&&t(il),e&&t($e),v(Cn),e&&t(dl),e&&t(qe),v(Nn),e&&t(ul),e&&t(Oe),v(zn),e&&t(ll),e&&t(Se),v(En),e&&t(pl),e&&t(Fe),v(Pn),e&&t(cl),e&&t(Me),v(Bn),e&&t(hl),e&&t(ke),v(Ln),e&&t(fl),e&&t(Ae),v(jn),e&&t(_l),e&&t(Ce),v(Wn),e&&t(ml),e&&t(Ne),v(Dn),e&&t(gl),e&&t(ze),v(Hn),e&&t(vl),e&&t(Ee),v(Qn),e&&t(yl),e&&t(Pe),v(In),e&&t(Tl),e&&t(Be),v(Vn),e&&t(wl),e&&t(Le),v(Rn),e&&t(bl),e&&t(je),v(Yn),e&&t(xl),e&&t(We),v(Un),e&&t($l),e&&t(De),v(Jn),e&&t(ql),e&&t(He),v(Gn),e&&t(Ol),e&&t(Qe),v(Kn),e&&t(Sl),e&&t(Ie),v(Xn),e&&t(Fl),e&&t(Ve),v(Zn),e&&t(Ml),e&&t(Re),v(es),e&&t(kl),e&&t(Ye),v(ts),e&&t(Al),e&&t(Ue),v(os),e&&t(Cl),e&&t(Je),v(ns),e&&t(Nl),e&&t(Ge),v(ss),e&&t(zl),e&&t(Ke),v(as),e&&t(El),e&&t(Xe),v(rs),e&&t(Pl),e&&t(Ze),v(is),e&&t(Bl),e&&t(et),v(ds),e&&t(Ll),e&&t(tt),v(us),e&&t(jl),e&&t(ot),v(ls),e&&t(Wl),e&&t(nt),v(ps),e&&t(Dl),e&&t(st),v(cs),e&&t(Hl),e&&t(at),v(hs),e&&t(Ql),e&&t(rt),v(fs),e&&t(Il),e&&t(it),v(_s),e&&t(Vl),e&&t(dt),v(ms),e&&t(Rl),e&&t(ut),v(gs),e&&t(Yl),e&&t(lt),v(vs),e&&t(Ul),e&&t(pt),v(ys),e&&t(Jl),e&&t(ct),v(Ts),e&&t(Gl),e&&t(ht),v(ws),e&&t(Kl),e&&t(ft),v(bs),e&&t(Xl),e&&t(_t),v(xs),e&&t(Zl),e&&t(mt),v($s),e&&t(ep),e&&t(gt),v(qs),e&&t(tp),e&&t(vt),v(Os),e&&t(op),e&&t(yt),v(Ss),e&&t(np),e&&t(Tt),v(Fs),e&&t(sp),e&&t(wt),v(Ms),e&&t(ap),e&&t(bt),v(ks),e&&t(rp),e&&t(xt),v(As),e&&t(ip),e&&t(N),v(Cs),v(Ns),e&&t(dp),e&&t($t),v(zs),e&&t(up),e&&t(z),v(Es),v(Ps),e&&t(lp),e&&t(qt),v(Bs),e&&t(pp),e&&t(E),v(Ls),v(js),e&&t(cp),e&&t(Ot),v(Ws),e&&t(hp),e&&t(P),v(Ds),v(Hs),e&&t(fp),e&&t(St),v(Qs),e&&t(_p),e&&t(B),v(Is),v(Vs),e&&t(mp),e&&t(Ft),v(Rs),e&&t(gp),e&&t(L),v(Ys),v(Us),e&&t(vp),e&&t(Mt),v(Js),e&&t(yp),e&&t(j),v(Gs),v(Ks),e&&t(Tp),e&&t(kt),v(Xs),e&&t(wp),e&&t(W),v(Zs),v(ea),e&&t(bp),e&&t(At),v(ta),e&&t(xp),e&&t(D),v(oa),v(na),e&&t($p),e&&t(Ct),v(sa),e&&t(qp),e&&t(H),v(aa),v(ra),e&&t(Op),e&&t(Nt),v(ia),e&&t(Sp),e&&t(Q),v(da),v(ua),e&&t(Fp),e&&t(zt),v(la),e&&t(Mp),e&&t(I),v(pa),v(ca),e&&t(kp),e&&t(Et),v(ha),e&&t(Ap),e&&t(V),v(fa),v(_a),e&&t(Cp),e&&t(Pt),v(ma),e&&t(Np),e&&t(R),v(ga),v(va),e&&t(zp),e&&t(Bt),v(ya),e&&t(Ep),e&&t(Y),v(Ta),v(wa)}}}const jb={local:"model-outputs",sections:[{local:"transformers.file_utils.ModelOutput",title:"ModelOutput"},{local:"transformers.modeling_outputs.BaseModelOutput",title:"BaseModelOutput"},{local:"transformers.modeling_outputs.BaseModelOutputWithPooling",title:"BaseModelOutputWithPooling"},{local:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions",title:"BaseModelOutputWithCrossAttentions"},{local:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions",title:"BaseModelOutputWithPoolingAndCrossAttentions"},{local:"transformers.modeling_outputs.BaseModelOutputWithPast",title:"BaseModelOutputWithPast"},{local:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions",title:"BaseModelOutputWithPastAndCrossAttentions"},{local:"transformers.modeling_outputs.Seq2SeqModelOutput",title:"Seq2SeqModelOutput"},{local:"transformers.modeling_outputs.CausalLMOutput",title:"CausalLMOutput"},{local:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions",title:"CausalLMOutputWithCrossAttentions"},{local:"transformers.modeling_outputs.CausalLMOutputWithPast",title:"CausalLMOutputWithPast"},{local:"transformers.modeling_outputs.MaskedLMOutput",title:"MaskedLMOutput"},{local:"transformers.modeling_outputs.Seq2SeqLMOutput",title:"Seq2SeqLMOutput"},{local:"transformers.modeling_outputs.NextSentencePredictorOutput",title:"NextSentencePredictorOutput"},{local:"transformers.modeling_outputs.SequenceClassifierOutput",title:"SequenceClassifierOutput"},{local:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput",title:"Seq2SeqSequenceClassifierOutput"},{local:"transformers.modeling_outputs.MultipleChoiceModelOutput",title:"MultipleChoiceModelOutput"},{local:"transformers.modeling_outputs.TokenClassifierOutput",title:"TokenClassifierOutput"},{local:"transformers.modeling_outputs.QuestionAnsweringModelOutput",title:"QuestionAnsweringModelOutput"},{local:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput",title:"Seq2SeqQuestionAnsweringModelOutput"},{local:"transformers.modeling_tf_outputs.TFBaseModelOutput",title:"TFBaseModelOutput"},{local:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling",title:"TFBaseModelOutputWithPooling"},{local:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions",title:"TFBaseModelOutputWithPoolingAndCrossAttentions"},{local:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPast",title:"TFBaseModelOutputWithPast"},{local:"transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions",title:"TFBaseModelOutputWithPastAndCrossAttentions"},{local:"transformers.modeling_tf_outputs.TFSeq2SeqModelOutput",title:"TFSeq2SeqModelOutput"},{local:"transformers.modeling_tf_outputs.TFCausalLMOutput",title:"TFCausalLMOutput"},{local:"transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions",title:"TFCausalLMOutputWithCrossAttentions"},{local:"transformers.modeling_tf_outputs.TFCausalLMOutputWithPast",title:"TFCausalLMOutputWithPast"},{local:"transformers.modeling_tf_outputs.TFMaskedLMOutput",title:"TFMaskedLMOutput"},{local:"transformers.modeling_tf_outputs.TFSeq2SeqLMOutput",title:"TFSeq2SeqLMOutput"},{local:"transformers.modeling_tf_outputs.TFNextSentencePredictorOutput",title:"TFNextSentencePredictorOutput"},{local:"transformers.modeling_tf_outputs.TFSequenceClassifierOutput",title:"TFSequenceClassifierOutput"},{local:"transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput",title:"TFSeq2SeqSequenceClassifierOutput"},{local:"transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput",title:"TFMultipleChoiceModelOutput"},{local:"transformers.modeling_tf_outputs.TFTokenClassifierOutput",title:"TFTokenClassifierOutput"},{local:"transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput",title:"TFQuestionAnsweringModelOutput"},{local:"transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput",title:"TFSeq2SeqQuestionAnsweringModelOutput"},{local:"transformers.modeling_flax_outputs.FlaxBaseModelOutput",title:"FlaxBaseModelOutput"},{local:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast",title:"FlaxBaseModelOutputWithPast"},{local:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling",title:"FlaxBaseModelOutputWithPooling"},{local:"transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions",title:"FlaxBaseModelOutputWithPastAndCrossAttentions"},{local:"transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput",title:"FlaxSeq2SeqModelOutput"},{local:"transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions",title:"FlaxCausalLMOutputWithCrossAttentions"},{local:"transformers.modeling_flax_outputs.FlaxMaskedLMOutput",title:"FlaxMaskedLMOutput"},{local:"transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput",title:"FlaxSeq2SeqLMOutput"},{local:"transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput",title:"FlaxNextSentencePredictorOutput"},{local:"transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput",title:"FlaxSequenceClassifierOutput"},{local:"transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput",title:"FlaxSeq2SeqSequenceClassifierOutput"},{local:"transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput",title:"FlaxMultipleChoiceModelOutput"},{local:"transformers.modeling_flax_outputs.FlaxTokenClassifierOutput",title:"FlaxTokenClassifierOutput"},{local:"transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput",title:"FlaxQuestionAnsweringModelOutput"},{local:"transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput",title:"FlaxSeq2SeqQuestionAnsweringModelOutput"}],title:"Model outputs"};function Wb(Ia,x,U){let{fw:$}=x;return Ia.$$set=q=>{"fw"in q&&U(0,$=q.fw)},[$]}class Yb extends Cb{constructor(x){super();Nb(this,x,Wb,Lb,zb,{fw:0})}}export{Yb as default,jb as metadata};
