import{S as TO,i as bO,s as wO,e as n,k as d,w as h,t as c,M as xO,c as s,d as t,m as i,a,x as f,h as p,b as r,G as o,g as l,y as m,q as _,o as g,B as v,v as $O}from"../../chunks/vendor-hf-doc-builder.js";import{T as qO}from"../../chunks/Tip-hf-doc-builder.js";import{D as y}from"../../chunks/Docstring-hf-doc-builder.js";import{C as yO}from"../../chunks/CodeBlock-hf-doc-builder.js";import{I as T}from"../../chunks/IconCopyLink-hf-doc-builder.js";function OO(tc){let x,no,$,A,J,q,En,K;return{c(){x=n("p"),no=c("You can\u2019t unpack a "),$=n("code"),A=c("ModelOutput"),J=c(" directly. Use the "),q=n("a"),En=c("to_tuple()"),K=c(` method to convert it to a tuple
before.`),this.h()},l(Z){x=s(Z,"P",{});var M=a(x);no=p(M,"You can\u2019t unpack a "),$=s(M,"CODE",{});var z=a($);A=p(z,"ModelOutput"),z.forEach(t),J=p(M," directly. Use the "),q=s(M,"A",{href:!0});var Tr=a(q);En=p(Tr,"to_tuple()"),Tr.forEach(t),K=p(M,` method to convert it to a tuple
before.`),M.forEach(t),this.h()},h(){r(q,"href","/docs/transformers/v4.27.1/en/main_classes/output#transformers.utils.ModelOutput.to_tuple")},m(Z,M){l(Z,x,M),o(x,no),o(x,$),o($,A),o(x,J),o(x,q),o(q,En),o(x,K)},d(Z){Z&&t(x)}}}function SO(tc){let x,no,$,A,J,q,En,K,Z,M,z,Tr,br,Zm,e_,oc,wr,t_,nc,Cn,sc,b,o_,Hr,n_,s_,xr,a_,r_,Ir,d_,i_,Vr,u_,l_,Qr,c_,p_,Rr,h_,f_,Xr,m_,__,Ur,g_,v_,Yr,y_,T_,Gr,b_,w_,Jr,x_,$_,Kr,q_,O_,ac,O,S_,Zr,F_,M_,ed,k_,A_,td,z_,N_,od,E_,C_,rc,S,P_,nd,B_,L_,sd,W_,j_,ad,D_,H_,rd,I_,V_,dc,Pn,ic,so,Q_,dd,R_,X_,uc,F,U_,id,Y_,G_,ud,J_,K_,ld,Z_,eg,cd,tg,og,lc,$r,ng,cc,ee,ao,pd,Bn,sg,hd,ag,pc,k,Ln,rg,te,dg,fd,ig,ug,md,lg,cg,pg,ro,hg,io,Wn,fg,jn,mg,_d,_g,gg,hc,oe,uo,gd,Dn,vg,vd,yg,fc,ne,Hn,Tg,yd,bg,mc,se,lo,Td,In,wg,bd,xg,_c,ae,Vn,$g,wd,qg,gc,re,co,xd,Qn,Og,$d,Sg,vc,de,Rn,Fg,qd,Mg,yc,ie,po,Od,Xn,kg,Sd,Ag,Tc,ue,Un,zg,Fd,Ng,bc,le,ho,Md,Yn,Eg,kd,Cg,wc,ce,Gn,Pg,Ad,Bg,xc,pe,fo,zd,Jn,Lg,Nd,Wg,$c,he,Kn,jg,Ed,Dg,qc,fe,mo,Cd,Zn,Hg,Pd,Ig,Oc,me,es,Vg,Bd,Qg,Sc,_e,_o,Ld,ts,Rg,Wd,Xg,Fc,ge,os,Ug,jd,Yg,Mc,ve,go,Dd,ns,Gg,Hd,Jg,kc,ye,ss,Kg,Id,Zg,Ac,Te,vo,Vd,as,ev,Qd,tv,zc,be,rs,ov,Rd,nv,Nc,we,yo,Xd,ds,sv,Ud,av,Ec,xe,is,rv,Yd,dv,Cc,$e,To,Gd,us,iv,Jd,uv,Pc,qe,ls,lv,Kd,cv,Bc,Oe,bo,Zd,cs,pv,ei,hv,Lc,Se,ps,fv,ti,mv,Wc,Fe,wo,oi,hs,_v,ni,gv,jc,Me,fs,vv,si,yv,Dc,ke,xo,ai,ms,Tv,ri,bv,Hc,Ae,_s,wv,di,xv,Ic,ze,$o,ii,gs,$v,ui,qv,Vc,Ne,vs,Ov,li,Sv,Qc,Ee,qo,ci,ys,Fv,pi,Mv,Rc,Ce,Ts,kv,hi,Av,Xc,Pe,Oo,fi,bs,zv,mi,Nv,Uc,Be,ws,Ev,_i,Cv,Yc,Le,So,gi,xs,Pv,vi,Bv,Gc,We,$s,Lv,yi,Wv,Jc,je,Fo,Ti,qs,jv,bi,Dv,Kc,De,Os,Hv,wi,Iv,Zc,He,Mo,xi,Ss,Vv,$i,Qv,ep,Ie,Fs,Rv,qi,Xv,tp,Ve,ko,Oi,Ms,Uv,Si,Yv,op,Qe,ks,Gv,Fi,Jv,np,Re,Ao,Mi,As,Kv,ki,Zv,sp,Xe,zs,ey,Ai,ty,ap,Ue,zo,zi,Ns,oy,Ni,ny,rp,Ye,Es,sy,Ei,ay,dp,Ge,No,Ci,Cs,ry,Pi,dy,ip,Je,Ps,iy,Bi,uy,up,Ke,Eo,Li,Bs,ly,Wi,cy,lp,Ze,Ls,py,Ws,hy,qr,fy,my,cp,et,Co,ji,js,_y,Di,gy,pp,tt,Ds,vy,Hi,yy,hp,ot,Po,Ii,Hs,Ty,Vi,by,fp,nt,Is,wy,Qi,xy,mp,st,Bo,Ri,Vs,$y,Xi,qy,_p,at,Qs,Oy,Ui,Sy,gp,rt,Lo,Yi,Rs,Fy,Gi,My,vp,dt,Xs,ky,Ji,Ay,yp,it,Wo,Ki,Us,zy,Zi,Ny,Tp,ut,Ys,Ey,eu,Cy,bp,lt,jo,tu,Gs,Py,ou,By,wp,ct,Js,Ly,nu,Wy,xp,pt,Do,su,Ks,jy,au,Dy,$p,ht,Zs,Hy,ru,Iy,qp,ft,Ho,du,ea,Vy,iu,Qy,Op,mt,ta,Ry,uu,Xy,Sp,_t,Io,lu,oa,Uy,cu,Yy,Fp,gt,na,Gy,pu,Jy,Mp,vt,Vo,hu,sa,Ky,fu,Zy,kp,yt,aa,eT,mu,tT,Ap,Tt,Qo,_u,ra,oT,gu,nT,zp,bt,da,sT,vu,aT,Np,wt,Ro,yu,ia,rT,Tu,dT,Ep,xt,ua,iT,bu,uT,Cp,$t,Xo,wu,la,lT,xu,cT,Pp,qt,ca,pT,$u,hT,Bp,Ot,Uo,qu,pa,fT,Ou,mT,Lp,St,ha,_T,Su,gT,Wp,Ft,Yo,Fu,fa,vT,Mu,yT,jp,Mt,ma,TT,ku,bT,Dp,kt,Go,Au,_a,wT,zu,xT,Hp,At,ga,$T,Nu,qT,Ip,zt,Jo,Eu,va,OT,Cu,ST,Vp,Nt,ya,FT,Pu,MT,Qp,Et,Ko,Bu,Ta,kT,Lu,AT,Rp,Ct,ba,zT,Wu,NT,Xp,Pt,Zo,ju,wa,ET,Du,CT,Up,Bt,xa,PT,Hu,BT,Yp,Lt,en,Iu,$a,LT,Vu,WT,Gp,Wt,qa,jT,Qu,DT,Jp,jt,tn,Ru,Oa,HT,Xu,IT,Kp,Dt,Sa,VT,Uu,QT,Zp,Ht,on,Yu,Fa,RT,Gu,XT,eh,N,Ma,UT,Ju,YT,GT,nn,ka,JT,Ku,KT,th,It,sn,Zu,Aa,ZT,el,e2,oh,E,za,t2,tl,o2,n2,an,Na,s2,ol,a2,nh,Vt,rn,nl,Ea,r2,sl,d2,sh,C,Ca,i2,al,u2,l2,dn,Pa,c2,rl,p2,ah,Qt,un,dl,Ba,h2,il,f2,rh,P,La,m2,ul,_2,g2,ln,Wa,v2,ll,y2,dh,Rt,cn,cl,ja,T2,pl,b2,ih,B,Da,w2,hl,x2,$2,pn,Ha,q2,fl,O2,uh,Xt,hn,ml,Ia,S2,_l,F2,lh,L,Va,M2,gl,k2,A2,fn,Qa,z2,vl,N2,ch,Ut,mn,yl,Ra,E2,Tl,C2,ph,W,Xa,P2,bl,B2,L2,_n,Ua,W2,wl,j2,hh,Yt,gn,xl,Ya,D2,$l,H2,fh,j,Ga,I2,ql,V2,Q2,vn,Ja,R2,Ol,X2,mh,Gt,yn,Sl,Ka,U2,Fl,Y2,_h,D,Za,G2,Ml,J2,K2,Tn,er,Z2,kl,eb,gh,Jt,bn,Al,tr,tb,zl,ob,vh,H,or,nb,Nl,sb,ab,wn,nr,rb,El,db,yh,Kt,xn,Cl,sr,ib,Pl,ub,Th,I,ar,lb,Bl,cb,pb,$n,rr,hb,Ll,fb,bh,Zt,qn,Wl,dr,mb,jl,_b,wh,V,ir,gb,Dl,vb,yb,On,ur,Tb,Hl,bb,xh,eo,Sn,Il,lr,wb,Vl,xb,$h,Q,cr,$b,Ql,qb,Ob,Fn,pr,Sb,Rl,Fb,qh,to,Mn,Xl,hr,Mb,Ul,kb,Oh,R,fr,Ab,Yl,zb,Nb,kn,mr,Eb,Gl,Cb,Sh,oo,An,Jl,_r,Pb,Kl,Bb,Fh,X,gr,Lb,Zl,Wb,jb,zn,vr,Db,ec,Hb,Mh;return q=new T({}),Cn=new yO({props:{code:`from transformers import BertTokenizer, BertForSequenceClassification
import torch

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

inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
labels = torch.tensor([1]).unsqueeze(0)  # Batch size 1
outputs = model(**inputs, labels=labels)`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> BertTokenizer, BertForSequenceClassification
<span class="hljs-keyword">import</span> torch

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

inputs = tokenizer(<span class="hljs-string">&quot;Hello, my dog is cute&quot;</span>, return_tensors=<span class="hljs-string">&quot;pt&quot;</span>)
labels = torch.tensor([<span class="hljs-number">1</span>]).unsqueeze(<span class="hljs-number">0</span>)  <span class="hljs-comment"># Batch size 1</span>
outputs = model(**inputs, labels=labels)`}}),Pn=new yO({props:{code:"outputs[:2]",highlighted:'outputs[:<span class="hljs-number">2</span>]'}}),Bn=new T({}),Ln=new y({props:{name:"class transformers.utils.ModelOutput",anchor:"transformers.utils.ModelOutput",parameters:"",source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/utils/generic.py#L205"}}),ro=new qO({props:{warning:!0,$$slots:{default:[OO]},$$scope:{ctx:tc}}}),Wn=new y({props:{name:"to_tuple",anchor:"transformers.utils.ModelOutput.to_tuple",parameters:[],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/utils/generic.py#L302"}}),Dn=new T({}),Hn=new y({props:{name:"class transformers.modeling_outputs.BaseModelOutput",anchor:"transformers.modeling_outputs.BaseModelOutput",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutput.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L24"}}),In=new T({}),Vn=new y({props:{name:"class transformers.modeling_outputs.BaseModelOutputWithPooling",anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"pooler_output",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling.pooler_output",description:`<strong>pooler_output</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, hidden_size)</code>) &#x2014;
Last layer hidden-state of the first token of the sequence (classification token) after further processing
through the layers used for the auxiliary pretraining task. E.g. for BERT-family of models, this returns
the classification token after processing through a linear layer and a tanh activation function. The linear
layer weights are trained from the next sentence prediction (classification) objective during pretraining.`,name:"pooler_output"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPooling.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L69"}}),Qn=new T({}),Rn=new y({props:{name:"class transformers.modeling_outputs.BaseModelOutputWithCrossAttentions",anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> and <code>config.add_cross_attention=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L162"}}),Xn=new T({}),Un=new y({props:{name:"class transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions",anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"pooler_output",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.pooler_output",description:`<strong>pooler_output</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, hidden_size)</code>) &#x2014;
Last layer hidden-state of the first token of the sequence (classification token) after further processing
through the layers used for the auxiliary pretraining task. E.g. for BERT-family of models, this returns
the classification token after processing through a linear layer and a tanh activation function. The linear
layer weights are trained from the next sentence prediction (classification) objective during pretraining.`,name:"pooler_output"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> and <code>config.add_cross_attention=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and optionally if
<code>config.is_encoder_decoder=True</code> 2 additional tensors of shape <code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and optionally if
<code>config.is_encoder_decoder=True</code> in the cross-attention blocks) that can be used (see <code>past_key_values</code>
input) to speed up sequential decoding.`,name:"past_key_values"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L195"}}),Yn=new T({}),Gn=new y({props:{name:"class transformers.modeling_outputs.BaseModelOutputWithPast",anchor:"transformers.modeling_outputs.BaseModelOutputWithPast",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithPast.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPast.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and optionally if
<code>config.is_encoder_decoder=True</code> 2 additional tensors of shape <code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and optionally if
<code>config.is_encoder_decoder=True</code> in the cross-attention blocks) that can be used (see <code>past_key_values</code>
input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPast.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPast.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L123"}}),Jn=new T({}),Kn=new y({props:{name:"class transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions",anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and optionally if
<code>config.is_encoder_decoder=True</code> 2 additional tensors of shape <code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and optionally if
<code>config.is_encoder_decoder=True</code> in the cross-attention blocks) that can be used (see <code>past_key_values</code>
input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"},{anchor:"transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> and <code>config.add_cross_attention=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L244"}}),Zn=new T({}),es=new y({props:{name:"class transformers.modeling_outputs.Seq2SeqModelOutput",anchor:"transformers.modeling_outputs.Seq2SeqModelOutput",parameters:[{name:"last_hidden_state",val:": FloatTensor = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[torch.FloatTensor] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.last_hidden_state",description:`<strong>last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>) &#x2014;
Sequence of hidden-states at the output of the last layer of the decoder of the model.</p>
<p>If <code>past_key_values</code> is used only the last hidden-state of the sequences of shape <code>(batch_size, 1, hidden_size)</code> is output.`,name:"last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and 2 additional tensors of shape
<code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
blocks) that can be used (see <code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the optional initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the optional initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqModelOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L424"}}),ts=new T({}),os=new y({props:{name:"class transformers.modeling_outputs.CausalLMOutput",anchor:"transformers.modeling_outputs.CausalLMOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.CausalLMOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss (for next-token prediction).`,name:"loss"},{anchor:"transformers.modeling_outputs.CausalLMOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.CausalLMOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.CausalLMOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L557"}}),ns=new T({}),ss=new y({props:{name:"class transformers.modeling_outputs.CausalLMOutputWithCrossAttentions",anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss (for next-token prediction).`,name:"loss"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Cross attentions weights after the attention softmax, used to compute the weighted average in the
cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithCrossAttentions.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> tuples of length <code>config.n_layers</code>, with each tuple containing the cached key,
value states of the self-attention and the cross-attention layers if model is used in encoder-decoder
setting. Only relevant if <code>config.is_decoder = True</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the attention blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L622"}}),as=new T({}),rs=new y({props:{name:"class transformers.modeling_outputs.CausalLMOutputWithPast",anchor:"transformers.modeling_outputs.CausalLMOutputWithPast",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss (for next-token prediction).`,name:"loss"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>)</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see
<code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.CausalLMOutputWithPast.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L586"}}),ds=new T({}),is=new y({props:{name:"class transformers.modeling_outputs.MaskedLMOutput",anchor:"transformers.modeling_outputs.MaskedLMOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.MaskedLMOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Masked language modeling (MLM) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.MaskedLMOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.MaskedLMOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.MaskedLMOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L702"}}),us=new T({}),ls=new y({props:{name:"class transformers.modeling_outputs.Seq2SeqLMOutput",anchor:"transformers.modeling_outputs.Seq2SeqLMOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[torch.FloatTensor] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Language modeling loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.vocab_size)</code>) &#x2014;
Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and 2 additional tensors of shape
<code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
blocks) that can be used (see <code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqLMOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L731"}}),cs=new T({}),ps=new y({props:{name:"class transformers.modeling_outputs.NextSentencePredictorOutput",anchor:"transformers.modeling_outputs.NextSentencePredictorOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.NextSentencePredictorOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>next_sentence_label</code> is provided) &#x2014;
Next sequence prediction (classification) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.NextSentencePredictorOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, 2)</code>) &#x2014;
Prediction scores of the next sequence prediction (classification) head (scores of True/False continuation
before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.NextSentencePredictorOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.NextSentencePredictorOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L866"}}),hs=new T({}),fs=new y({props:{name:"class transformers.modeling_outputs.SequenceClassifierOutput",anchor:"transformers.modeling_outputs.SequenceClassifierOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.SequenceClassifierOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.SequenceClassifierOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.num_labels)</code>) &#x2014;
Classification (or regression if config.num_labels==1) scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.SequenceClassifierOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.SequenceClassifierOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L896"}}),ms=new T({}),_s=new y({props:{name:"class transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput",anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[torch.FloatTensor] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>label</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.num_labels)</code>) &#x2014;
Classification (or regression if config.num_labels==1) scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and 2 additional tensors of shape
<code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
blocks) that can be used (see <code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L925"}}),gs=new T({}),vs=new y({props:{name:"class transformers.modeling_outputs.MultipleChoiceModelOutput",anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <em>(1,)</em>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, num_choices)</code>) &#x2014;
<em>num_choices</em> is the second dimension of the input tensors. (see <em>input_ids</em> above).</p>
<p>Classification scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.MultipleChoiceModelOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L985"}}),ys=new T({}),Ts=new y({props:{name:"class transformers.modeling_outputs.TokenClassifierOutput",anchor:"transformers.modeling_outputs.TokenClassifierOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.TokenClassifierOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided)  &#x2014;
Classification loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.TokenClassifierOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, config.num_labels)</code>) &#x2014;
Classification scores (before SoftMax).`,name:"logits"},{anchor:"transformers.modeling_outputs.TokenClassifierOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.TokenClassifierOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L1016"}}),bs=new T({}),ws=new y({props:{name:"class transformers.modeling_outputs.QuestionAnsweringModelOutput",anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"start_logits",val:": FloatTensor = None"},{name:"end_logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Total span extraction loss is the sum of a Cross-Entropy for the start and end positions.`,name:"loss"},{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.start_logits",description:`<strong>start_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-start scores (before SoftMax).`,name:"start_logits"},{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.end_logits",description:`<strong>end_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-end scores (before SoftMax).`,name:"end_logits"},{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.hidden_states",description:`<strong>hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the model at the output of each layer plus the optional initial embedding outputs.`,name:"hidden_states"},{anchor:"transformers.modeling_outputs.QuestionAnsweringModelOutput.attentions",description:`<strong>attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights after the attention softmax, used to compute the weighted average in the self-attention
heads.`,name:"attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L1045"}}),xs=new T({}),$s=new y({props:{name:"class transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput",anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"start_logits",val:": FloatTensor = None"},{name:"end_logits",val:": FloatTensor = None"},{name:"past_key_values",val:": typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None"},{name:"decoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"decoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"cross_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_last_hidden_state",val:": typing.Optional[torch.FloatTensor] = None"},{name:"encoder_hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"encoder_attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Total span extraction loss is the sum of a Cross-Entropy for the start and end positions.`,name:"loss"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.start_logits",description:`<strong>start_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-start scores (before SoftMax).`,name:"start_logits"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.end_logits",description:`<strong>end_logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length)</code>) &#x2014;
Span-end scores (before SoftMax).`,name:"end_logits"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.past_key_values",description:`<strong>past_key_values</strong> (<code>tuple(tuple(torch.FloatTensor))</code>, <em>optional</em>, returned when <code>use_cache=True</code> is passed or when <code>config.use_cache=True</code>) &#x2014;
Tuple of <code>tuple(torch.FloatTensor)</code> of length <code>config.n_layers</code>, with each tuple having 2 tensors of shape
<code>(batch_size, num_heads, sequence_length, embed_size_per_head)</code>) and 2 additional tensors of shape
<code>(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)</code>.</p>
<p>Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention
blocks) that can be used (see <code>past_key_values</code> input) to speed up sequential decoding.`,name:"past_key_values"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.decoder_hidden_states",description:`<strong>decoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the decoder at the output of each layer plus the initial embedding outputs.`,name:"decoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.decoder_attentions",description:`<strong>decoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"decoder_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.cross_attentions",description:`<strong>cross_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the decoder&#x2019;s cross-attention layer, after the attention softmax, used to compute the
weighted average in the cross-attention heads.`,name:"cross_attentions"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.encoder_last_hidden_state",description:`<strong>encoder_last_hidden_state</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, sequence_length, hidden_size)</code>, <em>optional</em>) &#x2014;
Sequence of hidden-states at the output of the last layer of the encoder of the model.`,name:"encoder_last_hidden_state"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.encoder_hidden_states",description:`<strong>encoder_hidden_states</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_hidden_states=True</code> is passed or when <code>config.output_hidden_states=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for the output of the embeddings, if the model has an embedding layer, +
one for the output of each layer) of shape <code>(batch_size, sequence_length, hidden_size)</code>.</p>
<p>Hidden-states of the encoder at the output of each layer plus the initial embedding outputs.`,name:"encoder_hidden_states"},{anchor:"transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput.encoder_attentions",description:`<strong>encoder_attentions</strong> (<code>tuple(torch.FloatTensor)</code>, <em>optional</em>, returned when <code>output_attentions=True</code> is passed or when <code>config.output_attentions=True</code>) &#x2014;
Tuple of <code>torch.FloatTensor</code> (one for each layer) of shape <code>(batch_size, num_heads, sequence_length, sequence_length)</code>.</p>
<p>Attentions weights of the encoder, after the attention softmax, used to compute the weighted average in the
self-attention heads.`,name:"encoder_attentions"}],source:"https://github.com/huggingface/transformers/blob/v4.27.1/src/transformers/modeling_outputs.py#L1077"}}),qs=new T({}),Os=new y({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/v4.27.1/src/transformers/modeling_outputs.py#L1410"}}),Ss=new T({}),Fs=new y({props:{name:"class transformers.modeling_outputs.SemanticSegmenterOutput",anchor:"transformers.modeling_outputs.SemanticSegmenterOutput",parameters:[{name:"loss",val:": typing.Optional[torch.FloatTensor] = None"},{name:"logits",val:": FloatTensor = None"},{name:"hidden_states",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"},{name:"attentions",val:": typing.Optional[typing.Tuple[torch.FloatTensor]] = None"}],parametersDescription:[{anchor:"transformers.modeling_outputs.SemanticSegmenterOutput.loss",description:`<strong>loss</strong> (<code>torch.FloatTensor</code> of shape <code>(1,)</code>, <em>optional</em>, returned when <code>labels</code> is provided) &#x2014;
Classification (or regression if config.num_labels==1) loss.`,name:"loss"},{anchor:"transformers.modeling_outputs.SemanticSegmenterOutput.logits",description:`<strong>logits</strong> (<code>torch.FloatTensor</code> of shape <code>(batch_size, config.num_labels, logits_height, logits_width)</code>) &#x2014;
Classification scores for each pixel.</p>
<div class="course-tip course-tip-orange bg-gradient-to-br dark:bg-gradient-to-r before:border-orange-500 dark:before:border-orange-800 from-orange-50 dark:from-gray-900 to-white dark:to-gray-950 border border-orange-50 text-orange-700 dark:text-gray-400">
						
<p>The logits returned do not necessarily have the same size as the <code>pixel_values</code> passed as inputs. This is
to avoid doing two interpolations and lose some quality when a user needs to resize the logits to the
original image size as post-processing. You should always check your logits shape and resize as needed.</p>

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