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