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

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

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

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

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

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