import{S as U$,i as Y$,s as G$,e as n,k as i,w as h,t as p,M as J$,c as s,d as t,m as d,a,x as f,h as c,b as r,G as o,g as l,y as m,q as _,o as g,B as v,v as K$}from"../../chunks/vendor-hf-doc-builder.js";import{T as Z$}from"../../chunks/Tip-hf-doc-builder.js";import{D as y}from"../../chunks/Docstring-hf-doc-builder.js";import{C as X$}from"../../chunks/CodeBlock-hf-doc-builder.js";import{I as T}from"../../chunks/IconCopyLink-hf-doc-builder.js";function eO(xl){let x,Yt,$,A,J,O,wn,K;return{c(){x=n("p"),Yt=p("You can\u2019t unpack a "),$=n("code"),A=p("ModelOutput"),J=p(" directly. Use the "),O=n("a"),wn=p("to_tuple()"),K=p(` method to convert it to a tuple
before.`),this.h()},l(Z){x=s(Z,"P",{});var M=a(x);Yt=c(M,"You can\u2019t unpack a "),$=s(M,"CODE",{});var C=a($);A=c(C,"ModelOutput"),C.forEach(t),J=c(M," directly. Use the "),O=s(M,"A",{href:!0});var er=a(O);wn=c(er,"to_tuple()"),er.forEach(t),K=c(M,` method to convert it to a tuple
before.`),M.forEach(t),this.h()},h(){r(O,"href","/docs/transformers/main/en/main_classes/output#transformers.utils.ModelOutput.to_tuple")},m(Z,M){l(Z,x,M),o(x,Yt),o(x,$),o($,A),o(x,J),o(x,O),o(O,wn),o(x,K)},d(Z){Z&&t(x)}}}function tO(xl){let x,Yt,$,A,J,O,wn,K,Z,M,C,er,tr,am,rm,$l,or,im,Ol,xn,ql,b,dm,wr,um,lm,nr,pm,cm,xr,hm,fm,$r,mm,_m,Or,gm,vm,qr,ym,Tm,Fr,bm,wm,Sr,xm,$m,Mr,Om,qm,kr,Fm,Sm,Ar,Mm,km,Cr,Am,Cm,Fl,q,Em,Er,Nm,zm,Nr,Pm,Bm,zr,Lm,Wm,Pr,jm,Dm,Sl,F,Hm,Br,Im,Vm,Lr,Qm,Rm,Wr,Xm,Um,jr,Ym,Gm,Ml,$n,kl,Gt,Jm,Dr,Km,Zm,Al,S,e_,Hr,t_,o_,Ir,n_,s_,Vr,a_,r_,Qr,i_,d_,Cl,sr,u_,El,ee,Jt,Rr,On,l_,Xr,p_,Nl,k,qn,c_,te,h_,Ur,f_,m_,Yr,__,g_,v_,Kt,y_,Zt,Fn,T_,Sn,b_,Gr,w_,x_,zl,oe,eo,Jr,Mn,$_,Kr,O_,Pl,ne,kn,q_,Zr,F_,Bl,se,to,ei,An,S_,ti,M_,Ll,ae,Cn,k_,oi,A_,Wl,re,oo,ni,En,C_,si,E_,jl,ie,Nn,N_,ai,z_,Dl,de,no,ri,zn,P_,ii,B_,Hl,ue,Pn,L_,di,W_,Il,le,so,ui,Bn,j_,li,D_,Vl,pe,Ln,H_,pi,I_,Ql,ce,ao,ci,Wn,V_,hi,Q_,Rl,he,jn,R_,fi,X_,Xl,fe,ro,mi,Dn,U_,_i,Y_,Ul,me,Hn,G_,gi,J_,Yl,_e,io,vi,In,K_,yi,Z_,Gl,ge,Vn,eg,Ti,tg,Jl,ve,uo,bi,Qn,og,wi,ng,Kl,ye,Rn,sg,xi,ag,Zl,Te,lo,$i,Xn,rg,Oi,ig,ep,be,Un,dg,qi,ug,tp,we,po,Fi,Yn,lg,Si,pg,op,xe,Gn,cg,Mi,hg,np,$e,co,ki,Jn,fg,Ai,mg,sp,Oe,Kn,_g,Ci,gg,ap,qe,ho,Ei,Zn,vg,Ni,yg,rp,Fe,es,Tg,zi,bg,ip,Se,fo,Pi,ts,wg,Bi,xg,dp,Me,os,$g,Li,Og,up,ke,mo,Wi,ns,qg,ji,Fg,lp,Ae,ss,Sg,Di,Mg,pp,Ce,_o,Hi,as,kg,Ii,Ag,cp,Ee,rs,Cg,Vi,Eg,hp,Ne,go,Qi,is,Ng,Ri,zg,fp,ze,ds,Pg,Xi,Bg,mp,Pe,vo,Ui,us,Lg,Yi,Wg,_p,Be,ls,jg,Gi,Dg,gp,Le,yo,Ji,ps,Hg,Ki,Ig,vp,We,cs,Vg,Zi,Qg,yp,je,To,ed,hs,Rg,td,Xg,Tp,De,fs,Ug,od,Yg,bp,He,bo,nd,ms,Gg,sd,Jg,wp,Ie,_s,Kg,ad,Zg,xp,Ve,wo,rd,gs,ev,id,tv,$p,Qe,vs,ov,dd,nv,Op,Re,xo,ud,ys,sv,ld,av,qp,Xe,Ts,rv,pd,iv,Fp,Ue,$o,cd,bs,dv,hd,uv,Sp,Ye,ws,lv,fd,pv,Mp,Ge,Oo,md,xs,cv,_d,hv,kp,Je,$s,fv,Os,mv,ar,_v,gv,Ap,Ke,qo,gd,qs,vv,vd,yv,Cp,Ze,Fs,Tv,yd,bv,Ep,et,Fo,Td,Ss,wv,bd,xv,Np,tt,Ms,$v,wd,Ov,zp,ot,So,xd,ks,qv,$d,Fv,Pp,nt,As,Sv,Od,Mv,Bp,st,Mo,qd,Cs,kv,Fd,Av,Lp,at,Es,Cv,Sd,Ev,Wp,rt,ko,Md,Ns,Nv,kd,zv,jp,it,zs,Pv,Ad,Bv,Dp,dt,Ao,Cd,Ps,Lv,Ed,Wv,Hp,ut,Bs,jv,Nd,Dv,Ip,lt,Co,zd,Ls,Hv,Pd,Iv,Vp,pt,Ws,Vv,Bd,Qv,Qp,ct,Eo,Ld,js,Rv,Wd,Xv,Rp,ht,Ds,Uv,jd,Yv,Xp,ft,No,Dd,Hs,Gv,Hd,Jv,Up,mt,Is,Kv,Id,Zv,Yp,_t,zo,Vd,Vs,ey,Qd,ty,Gp,gt,Qs,oy,Rd,ny,Jp,vt,Po,Xd,Rs,sy,Ud,ay,Kp,yt,Xs,ry,Yd,iy,Zp,Tt,Bo,Gd,Us,dy,Jd,uy,ec,bt,Ys,ly,Kd,py,tc,wt,Lo,Zd,Gs,cy,eu,hy,oc,xt,Js,fy,tu,my,nc,$t,Wo,ou,Ks,_y,nu,gy,sc,Ot,Zs,vy,su,yy,ac,qt,jo,au,ea,Ty,ru,by,rc,Ft,ta,wy,iu,xy,ic,St,Do,du,oa,$y,uu,Oy,dc,Mt,na,qy,lu,Fy,uc,kt,Ho,pu,sa,Sy,cu,My,lc,At,aa,ky,hu,Ay,pc,Ct,Io,fu,ra,Cy,mu,Ey,cc,Et,ia,Ny,_u,zy,hc,Nt,Vo,gu,da,Py,vu,By,fc,E,ua,Ly,yu,Wy,jy,Qo,la,Dy,Tu,Hy,mc,zt,Ro,bu,pa,Iy,wu,Vy,_c,N,ca,Qy,xu,Ry,Xy,Xo,ha,Uy,$u,Yy,gc,Pt,Uo,Ou,fa,Gy,qu,Jy,vc,z,ma,Ky,Fu,Zy,eT,Yo,_a,tT,Su,oT,yc,Bt,Go,Mu,ga,nT,ku,sT,Tc,P,va,aT,Au,rT,iT,Jo,ya,dT,Cu,uT,bc,Lt,Ko,Eu,Ta,lT,Nu,pT,wc,B,ba,cT,zu,hT,fT,Zo,wa,mT,Pu,_T,xc,Wt,en,Bu,xa,gT,Lu,vT,$c,L,$a,yT,Wu,TT,bT,tn,Oa,wT,ju,xT,Oc,jt,on,Du,qa,$T,Hu,OT,qc,W,Fa,qT,Iu,FT,ST,nn,Sa,MT,Vu,kT,Fc,Dt,sn,Qu,Ma,AT,Ru,CT,Sc,j,ka,ET,Xu,NT,zT,an,Aa,PT,Uu,BT,Mc,Ht,rn,Yu,Ca,LT,Gu,WT,kc,D,Ea,jT,Ju,DT,HT,dn,Na,IT,Ku,VT,Ac,It,un,Zu,za,QT,el,RT,Cc,H,Pa,XT,tl,UT,YT,ln,Ba,GT,ol,JT,Ec,Vt,pn,nl,La,KT,sl,ZT,Nc,I,Wa,eb,al,tb,ob,cn,ja,nb,rl,sb,zc,Qt,hn,il,Da,ab,dl,rb,Pc,V,Ha,ib,ul,db,ub,fn,Ia,lb,ll,pb,Bc,Rt,mn,pl,Va,cb,cl,hb,Lc,Q,Qa,fb,hl,mb,_b,_n,Ra,gb,fl,vb,Wc,Xt,gn,ml,Xa,yb,_l,Tb,jc,R,Ua,bb,gl,wb,xb,vn,Ya,$b,vl,Ob,Dc,Ut,yn,yl,Ga,qb,Tl,Fb,Hc,X,Ja,Sb,bl,Mb,kb,Tn,Ka,Ab,wl,Cb,Ic;return O=new T({}),xn=new X$({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)`}}),$n=new X$({props:{code:"outputs[:2]",highlighted:'outputs[:<span class="hljs-number">2</span>]'}}),On=new T({}),qn=new y({props:{name:"class transformers.utils.ModelOutput",anchor:"transformers.utils.ModelOutput",parameters:"",source:"https://github.com/huggingface/transformers/blob/main/src/transformers/utils/generic.py#L205"}}),Kt=new Z$({props:{warning:!0,$$slots:{default:[eO]},$$scope:{ctx:xl}}}),Fn=new y({props:{name:"to_tuple",anchor:"transformers.utils.ModelOutput.to_tuple",parameters:[],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/utils/generic.py#L302"}}),Mn=new T({}),kn=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutput.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L24"}}),An=new T({}),Cn=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling.pooler_output",description:`<strong>pooler_output</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, hidden_size)</code>) &#x2014;
Last layer hidden-state of the first token of the sequence (classification token) after further processing
through the layers used for the auxiliary pretraining task. E.g. for BERT-family of models, this returns
the classification token after processing through a linear layer and a tanh activation function. The linear
layer weights are trained from the next sentence prediction (classification) objective during pretraining.`,name:"pooler_output"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L69"}}),En=new T({}),Nn=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> and <code>config.add_cross_attention=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L162"}}),zn=new T({}),Pn=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.pooler_output",description:`<strong>pooler_output</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, hidden_size)</code>) &#x2014;
Last layer hidden-state of the first token of the sequence (classification token) after further processing
through the layers used for the auxiliary pretraining task. E.g. for BERT-family of models, this returns
the classification token after processing through a linear layer and a tanh activation function. The linear
layer weights are trained from the next sentence prediction (classification) objective during pretraining.`,name:"pooler_output"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> and <code>config.add_cross_attention=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and optionally if
<code>config.is_encoder_decoder=True</code> 2 additional tensors of shape <code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and optionally if
<code>config.is_encoder_decoder=True</code> in the cross-attention blocks) that can be used (see <code>past_key_values</code>
input) to speed up sequential decoding.`,name:"past_key_values"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L195"}}),Bn=new T({}),Ln=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithPast.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPast.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and optionally if
<code>config.is_encoder_decoder=True</code> 2 additional tensors of shape <code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and optionally if
<code>config.is_encoder_decoder=True</code> in the cross-attention blocks) that can be used (see <code>past_key_values</code>
input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPast.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPast.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L123"}}),Wn=new T({}),jn=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and optionally if
<code>config.is_encoder_decoder=True</code> 2 additional tensors of shape <code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and optionally if
<code>config.is_encoder_decoder=True</code> in the cross-attention blocks) that can be used (see <code>past_key_values</code>
input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> and <code>config.add_cross_attention=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L244"}}),Dn=new T({}),Hn=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the decoder of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and 2 additional tensors of shape
<code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
blocks) that can be used (see <code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the optional initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the optional initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L375"}}),In=new T({}),Vn=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.CausalLMOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss (for next-token prediction).`,name:"loss"},{anchor:"transformers.modeling_outputs.CausalLMOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.CausalLMOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.CausalLMOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L508"}}),Qn=new T({}),Rn=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss (for next-token prediction).`,name:"loss"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Cross attentions weights after the attention softmax, used to compute the weighted average in the
cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> tuples of length <code>config.n_layers</code>, with each tuple containing the cached key,
value states of the self-attention and the cross-attention layers if model is used in encoder-decoder
setting. Only relevant if <code>config.is_decoder = True</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the attention blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L573"}}),Xn=new T({}),Un=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss (for next-token prediction).`,name:"loss"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>)</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L537"}}),Yn=new T({}),Gn=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.MaskedLMOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Masked language modeling (MLM) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.MaskedLMOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.MaskedLMOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.MaskedLMOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L653"}}),Jn=new T({}),Kn=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and 2 additional tensors of shape
<code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
blocks) that can be used (see <code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L682"}}),Zn=new T({}),es=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.NextSentencePredictorOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>next_sentence_label</code> is provided) &#x2014;
Next sequence prediction (classification) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.NextSentencePredictorOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, 2)</code>) &#x2014;
Prediction scores of the next sequence prediction (classification) head (scores of True/False continuation
before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.NextSentencePredictorOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.NextSentencePredictorOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L817"}}),ts=new T({}),os=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.SequenceClassifierOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.SequenceClassifierOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.num_labels)</code>) &#x2014;
Classification (or regression if config.num_labels==1) scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.SequenceClassifierOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.SequenceClassifierOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L847"}}),ns=new T({}),ss=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>label</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.num_labels)</code>) &#x2014;
Classification (or regression if config.num_labels==1) scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and 2 additional tensors of shape
<code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
blocks) that can be used (see <code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L876"}}),as=new T({}),rs=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <em>(1,)</em>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_choices)</code>) &#x2014;
<em>num_choices</em> is the second dimension of the input tensors. (see <em>input_ids</em> above).</p>
<p>Classification scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L936"}}),is=new T({}),ds=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.TokenClassifierOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided)  &#x2014;
Classification loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.TokenClassifierOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.num_labels)</code>) &#x2014;
Classification scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.TokenClassifierOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.TokenClassifierOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L967"}}),us=new T({}),ls=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Total span extraction loss is the sum of a Cross-Entropy for the start and end positions.`,name:"loss"},{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.start_logits",description:`<strong>start_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-start scores (before SoftMax).`,name:"start_logits"},{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.end_logits",description:`<strong>end_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-end scores (before SoftMax).`,name:"end_logits"},{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L996"}}),ps=new T({}),cs=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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Total span extraction loss is the sum of a Cross-Entropy for the start and end positions.`,name:"loss"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.start_logits",description:`<strong>start_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-start scores (before SoftMax).`,name:"start_logits"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.end_logits",description:`<strong>end_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-end scores (before SoftMax).`,name:"end_logits"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and 2 additional tensors of shape
<code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
blocks) that can be used (see <code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_outputs.py#L1028"}}),hs=new T({}),fs=new y({props:{name:"class transformers.modeling_outputs.SemanticSegmenterOutput",anchor:"transformers.modeling_outputs.SemanticSegmenterOutput",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"}],parametersDescription:[{anchor:"transformers.modeling_outputs.SemanticSegmenterOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.SemanticSegmenterOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.num_labels, logits_height, logits_width)</code>) &#x2014;
Classification scores for each pixel.</p>
<div class="course-tip course-tip-orange bg-gradient-to-br dark:bg-gradient-to-r before:border-orange-500 dark:before:border-orange-800 from-orange-50 dark:from-gray-900 to-white dark:to-gray-950 border border-orange-50 text-orange-700 dark:text-gray-400">
						
<p>The logits returned do not necessarily have the same size as the <code>pixel_values</code> passed as inputs. This is
to avoid doing two interpolations and lose some quality when a user needs to resize the logits to the
original image size as post-processing. You should always check your logits shape and resize as needed.</p>

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