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