import{S as Nv,i as jv,s as kv,e as r,k as d,w as g,t,M as Tv,c as n,d as a,m as p,a as l,x,h as s,b as _,G as e,g as m,y as $,q as O,o as b,B as q,v as wv}from"../chunks/vendor-hf-doc-builder.js";import{T as va}from"../chunks/Tip-hf-doc-builder.js";import{I as lo}from"../chunks/IconCopyLink-hf-doc-builder.js";import{C as z}from"../chunks/CodeBlock-hf-doc-builder.js";function Dv(B){let f,D,h,N,T;return{c(){f=r("p"),D=t(`Uma vez exportado, um modelo pode ser otimizado para infer\xEAncia por meio de t\xE9cnicas como
quantiza\xE7\xE3o e poda. Se voc\xEA estiver interessado em otimizar seus modelos para serem executados com
m\xE1xima efici\xEAncia, confira a biblioteca `),h=r("a"),N=t(`\u{1F917} Optimum
`),T=t("."),this.h()},l(v){f=n(v,"P",{});var E=l(f);D=s(E,`Uma vez exportado, um modelo pode ser otimizado para infer\xEAncia por meio de t\xE9cnicas como
quantiza\xE7\xE3o e poda. Se voc\xEA estiver interessado em otimizar seus modelos para serem executados com
m\xE1xima efici\xEAncia, confira a biblioteca `),h=n(E,"A",{href:!0,rel:!0});var C=l(h);N=s(C,`\u{1F917} Optimum
`),C.forEach(a),T=s(E,"."),E.forEach(a),this.h()},h(){_(h,"href","https://github.com/huggingface/optimum"),_(h,"rel","nofollow")},m(v,E){m(v,f,E),e(f,D),e(f,h),e(h,N),e(f,T)},d(v){v&&a(f)}}}function Cv(B){let f,D,h,N,T,v,E,C;return{c(){f=r("p"),D=t("Os recursos que t\xEAm um sufixo "),h=r("code"),N=t("with-pass"),T=t(" (como "),v=r("code"),E=t("causal-lm-with-pass"),C=t(`) correspondem a
classes de modelo com estados ocultos pr\xE9-computados (chave e valores nos blocos de aten\xE7\xE3o)
que pode ser usado para decodifica\xE7\xE3o autorregressiva r\xE1pida.`)},l(j){f=n(j,"P",{});var k=l(f);D=s(k,"Os recursos que t\xEAm um sufixo "),h=n(k,"CODE",{});var A=l(h);N=s(A,"with-pass"),A.forEach(a),T=s(k," (como "),v=n(k,"CODE",{});var P=l(v);E=s(P,"causal-lm-with-pass"),P.forEach(a),C=s(k,`) correspondem a
classes de modelo com estados ocultos pr\xE9-computados (chave e valores nos blocos de aten\xE7\xE3o)
que pode ser usado para decodifica\xE7\xE3o autorregressiva r\xE1pida.`),k.forEach(a)},m(j,k){m(j,f,k),e(f,D),e(f,h),e(h,N),e(f,T),e(f,v),e(v,E),e(f,C)},d(j){j&&a(f)}}}function Pv(B){let f,D,h,N,T,v,E,C,j,k,A;return{c(){f=r("p"),D=t("Para modelos do tipo "),h=r("code"),N=t("VisionEncoderDecoder"),T=t(`, as partes do codificador e do decodificador s\xE3o
exportados separadamente como dois arquivos ONNX chamados `),v=r("code"),E=t("encoder_model.onnx"),C=t(" e "),j=r("code"),k=t("decoder_model.onnx"),A=t(" respectivamente.")},l(P){f=n(P,"P",{});var w=l(f);D=s(w,"Para modelos do tipo "),h=n(w,"CODE",{});var U=l(h);N=s(U,"VisionEncoderDecoder"),U.forEach(a),T=s(w,`, as partes do codificador e do decodificador s\xE3o
exportados separadamente como dois arquivos ONNX chamados `),v=n(w,"CODE",{});var S=l(v);E=s(S,"encoder_model.onnx"),S.forEach(a),C=s(w," e "),j=n(w,"CODE",{});var F=l(j);k=s(F,"decoder_model.onnx"),F.forEach(a),A=s(w," respectivamente."),w.forEach(a)},m(P,w){m(P,f,w),e(f,D),e(f,h),e(h,N),e(f,T),e(f,v),e(v,E),e(f,C),e(f,j),e(j,k),e(f,A)},d(P){P&&a(f)}}}function Lv(B){let f,D,h,N,T;return{c(){f=r("p"),D=t(`Uma boa maneira de implementar uma configura\xE7\xE3o ONNX personalizada \xE9 observar as
implementa\xE7\xE3o no arquivo `),h=r("code"),N=t("configuration_<model_name>.py"),T=t(" de uma arquitetura semelhante.")},l(v){f=n(v,"P",{});var E=l(f);D=s(E,`Uma boa maneira de implementar uma configura\xE7\xE3o ONNX personalizada \xE9 observar as
implementa\xE7\xE3o no arquivo `),h=n(E,"CODE",{});var C=l(h);N=s(C,"configuration_<model_name>.py"),C.forEach(a),T=s(E," de uma arquitetura semelhante."),E.forEach(a)},m(v,E){m(v,f,E),e(f,D),e(f,h),e(h,N),e(f,T)},d(v){v&&a(f)}}}function Av(B){let f,D,h,N,T,v,E,C,j,k,A,P,w,U,S,F,W,re,K,io,oe,po,mo,xe,L,co,ne,Q,uo,J,$e,fo,Oe,Ce,le,be,Pe,c,ae,ho,vo,te,_o,Eo,se,go,xo;return{c(){f=r("p"),D=t("Notice that "),h=r("code"),N=t("inputs"),T=t(" property for "),v=r("code"),E=t("DistilBertOnnxConfig"),C=t(" returns an "),j=r("code"),k=t("OrderedDict"),A=t(`. This
ensures that the inputs are matched with their relative position within the
`),P=r("code"),w=t("PreTrainedModel.forward()"),U=t(` method when tracing the graph. We recommend using an
`),S=r("code"),F=t("OrderedDict"),W=t(" for the "),re=r("code"),K=t("inputs"),io=t(" and "),oe=r("code"),po=t("outputs"),mo=t(` properties when implementing custom ONNX
configurations.`),xe=d(),L=r("p"),co=t("Observe que a propriedade "),ne=r("code"),Q=t("inputs"),uo=t(" para "),J=r("code"),$e=t("DistilBertOnnxConfig"),fo=t(" retorna um "),Oe=r("code"),Ce=t("OrderedDict"),le=t(`. Este
garante que as entradas sejam combinadas com sua posi\xE7\xE3o relativa dentro do
m\xE9todo `),be=r("code"),Pe=t("PreTrainedModel.forward()"),c=t(` ao tra\xE7ar o grafo. Recomendamos o uso de um
`),ae=r("code"),ho=t("OrderedDict"),vo=t(" para as propriedades "),te=r("code"),_o=t("inputs"),Eo=t(" e "),se=r("code"),go=t("outputs"),xo=t(" ao implementar configura\xE7\xF5es personalizadas ONNX.")},l(X){f=n(X,"P",{});var y=l(f);D=s(y,"Notice that "),h=n(y,"CODE",{});var _a=l(h);N=s(_a,"inputs"),_a.forEach(a),T=s(y," property for "),v=n(y,"CODE",{});var Le=l(v);E=s(Le,"DistilBertOnnxConfig"),Le.forEach(a),C=s(y," returns an "),j=n(y,"CODE",{});var Ea=l(j);k=s(Ea,"OrderedDict"),Ea.forEach(a),A=s(y,`. This
ensures that the inputs are matched with their relative position within the
`),P=n(y,"CODE",{});var ga=l(P);w=s(ga,"PreTrainedModel.forward()"),ga.forEach(a),U=s(y,` method when tracing the graph. We recommend using an
`),S=n(y,"CODE",{});var Ae=l(S);F=s(Ae,"OrderedDict"),Ae.forEach(a),W=s(y," for the "),re=n(y,"CODE",{});var xa=l(re);K=s(xa,"inputs"),xa.forEach(a),io=s(y," and "),oe=n(y,"CODE",{});var $a=l(oe);po=s($a,"outputs"),$a.forEach(a),mo=s(y,` properties when implementing custom ONNX
configurations.`),y.forEach(a),xe=p(X),L=n(X,"P",{});var I=l(L);co=s(I,"Observe que a propriedade "),ne=n(I,"CODE",{});var Oa=l(ne);Q=s(Oa,"inputs"),Oa.forEach(a),uo=s(I," para "),J=n(I,"CODE",{});var ba=l(J);$e=s(ba,"DistilBertOnnxConfig"),ba.forEach(a),fo=s(I," retorna um "),Oe=n(I,"CODE",{});var ye=l(Oe);Ce=s(ye,"OrderedDict"),ye.forEach(a),le=s(I,`. Este
garante que as entradas sejam combinadas com sua posi\xE7\xE3o relativa dentro do
m\xE9todo `),be=n(I,"CODE",{});var qa=l(be);Pe=s(qa,"PreTrainedModel.forward()"),qa.forEach(a),c=s(I,` ao tra\xE7ar o grafo. Recomendamos o uso de um
`),ae=n(I,"CODE",{});var Na=l(ae);ho=s(Na,"OrderedDict"),Na.forEach(a),vo=s(I," para as propriedades "),te=n(I,"CODE",{});var Ie=l(te);_o=s(Ie,"inputs"),Ie.forEach(a),Eo=s(I," e "),se=n(I,"CODE",{});var ja=l(se);go=s(ja,"outputs"),ja.forEach(a),xo=s(I," ao implementar configura\xE7\xF5es personalizadas ONNX."),I.forEach(a)},m(X,y){m(X,f,y),e(f,D),e(f,h),e(h,N),e(f,T),e(f,v),e(v,E),e(f,C),e(f,j),e(j,k),e(f,A),e(f,P),e(P,w),e(f,U),e(f,S),e(S,F),e(f,W),e(f,re),e(re,K),e(f,io),e(f,oe),e(oe,po),e(f,mo),m(X,xe,y),m(X,L,y),e(L,co),e(L,ne),e(ne,Q),e(L,uo),e(L,J),e(J,$e),e(L,fo),e(L,Oe),e(Oe,Ce),e(L,le),e(L,be),e(be,Pe),e(L,c),e(L,ae),e(ae,ho),e(L,vo),e(L,te),e(te,_o),e(L,Eo),e(L,se),e(se,go),e(L,xo)},d(X){X&&a(f),X&&a(xe),X&&a(L)}}}function yv(B){let f,D,h,N,T,v,E,C;return{c(){f=r("p"),D=t("Todas as propriedades e m\xE9todos b\xE1sicos associados a "),h=r("code"),N=t("OnnxConfig"),T=t(` e
as outras classes de configura\xE7\xE3o podem ser substitu\xEDdas se necess\xE1rio. Confira `),v=r("code"),E=t("BartOnnxConfig"),C=t(`
para um exemplo avan\xE7ado.`)},l(j){f=n(j,"P",{});var k=l(f);D=s(k,"Todas as propriedades e m\xE9todos b\xE1sicos associados a "),h=n(k,"CODE",{});var A=l(h);N=s(A,"OnnxConfig"),A.forEach(a),T=s(k,` e
as outras classes de configura\xE7\xE3o podem ser substitu\xEDdas se necess\xE1rio. Confira `),v=n(k,"CODE",{});var P=l(v);E=s(P,"BartOnnxConfig"),P.forEach(a),C=s(k,`
para um exemplo avan\xE7ado.`),k.forEach(a)},m(j,k){m(j,f,k),e(f,D),e(f,h),e(h,N),e(f,T),e(f,v),e(v,E),e(f,C)},d(j){j&&a(f)}}}function Iv(B){let f,D,h,N,T,v,E,C,j,k,A;return{c(){f=r("p"),D=t(`Se o seu modelo for maior que 2GB, voc\xEA ver\xE1 que muitos arquivos adicionais s\xE3o criados
durante a exporta\xE7\xE3o. Isso \xE9 `),h=r("em"),N=t("esperado"),T=t(" porque o ONNX usa "),v=r("a"),E=t(`Protocol
Buffers`),C=t(` para armazenar o modelo e estes
t\xEAm um limite de tamanho de 2GB. Veja a `),j=r("a"),k=t(`ONNX
documenta\xE7\xE3o`),A=t(` para
instru\xE7\xF5es sobre como carregar modelos com dados externos.`),this.h()},l(P){f=n(P,"P",{});var w=l(f);D=s(w,`Se o seu modelo for maior que 2GB, voc\xEA ver\xE1 que muitos arquivos adicionais s\xE3o criados
durante a exporta\xE7\xE3o. Isso \xE9 `),h=n(w,"EM",{});var U=l(h);N=s(U,"esperado"),U.forEach(a),T=s(w," porque o ONNX usa "),v=n(w,"A",{href:!0,rel:!0});var S=l(v);E=s(S,`Protocol
Buffers`),S.forEach(a),C=s(w,` para armazenar o modelo e estes
t\xEAm um limite de tamanho de 2GB. Veja a `),j=n(w,"A",{href:!0,rel:!0});var F=l(j);k=s(F,`ONNX
documenta\xE7\xE3o`),F.forEach(a),A=s(w,` para
instru\xE7\xF5es sobre como carregar modelos com dados externos.`),w.forEach(a),this.h()},h(){_(v,"href","https://developers.google.com/protocol-buffers/"),_(v,"rel","nofollow"),_(j,"href","https://github.com/onnx/onnx/blob/master/docs/ExternalData.md"),_(j,"rel","nofollow")},m(P,w){m(P,f,w),e(f,D),e(f,h),e(h,N),e(f,T),e(f,v),e(v,E),e(f,C),e(f,j),e(j,k),e(f,A)},d(P){P&&a(f)}}}function zv(B){let f,D,h,N,T,v,E,C,j,k,A,P,w,U,S,F,W,re,K,io,oe,po,mo,xe,L,co,ne,Q,uo,J,$e,fo,Oe,Ce,le,be,Pe,c,ae,ho,vo,te,_o,Eo,se,go,xo,X,y,_a,Le,Ea,ga,Ae,xa,$a,I,Oa,ba,ye,qa,Na,Ie,ja,yl,ot,Il,zl,at,Xl,Ml,tt,Bl,Rl,st,Sl,Fl,rt,Vl,Hl,nt,Gl,Ul,lt,Wl,Kl,it,Ql,Jl,dt,Yl,Zl,pt,ei,oi,mt,ai,ti,ct,si,ri,ut,ni,li,ft,ii,di,ht,pi,mi,vt,ci,ui,_t,fi,hi,Et,vi,_i,gt,Ei,gi,xt,xi,$i,$t,Oi,bi,Ot,qi,Ni,bt,ji,ki,qt,Ti,wi,Nt,Di,Ci,jt,Pi,Li,kt,Ai,yi,Tt,Ii,zi,wt,Xi,Mi,Dt,Bi,Ri,Ct,Si,Fi,Pt,Vi,Hi,Lt,Gi,Ui,At,Wi,Ki,yt,Qi,Ji,It,Yi,Zi,zt,ed,od,Xt,ad,td,Mt,sd,rd,Bt,nd,ld,Rt,id,dd,St,pd,md,Ft,cd,ud,Vt,fd,hd,Ht,vd,_d,Gt,Ed,gd,Ut,xd,$d,Wt,Od,bd,Kt,qd,Nd,Qt,jd,Mr,ka,kd,Br,ze,$o,Td,Jt,wd,Dd,Cd,Yt,Pd,Rr,qe,Xe,Zt,Oo,Ld,es,Ad,Sr,Ta,yd,Fr,bo,Vr,Me,Id,os,zd,Xd,Hr,qo,Gr,wa,Md,Ur,No,Wr,Da,Bd,Kr,jo,Qr,ie,Rd,as,Sd,Fd,ts,Vd,Hd,Jr,Y,Gd,ss,Ud,Wd,ko,Kd,Qd,To,Jd,Yd,Yr,wo,Zr,Be,Zd,rs,ep,op,en,Do,on,Re,ap,Co,tp,sp,an,Po,tn,Ca,rp,sn,Lo,rn,de,np,ns,lp,ip,ls,dp,pp,nn,Ao,ln,yo,dn,pe,mp,is,cp,up,ds,fp,hp,pn,Io,mn,Ne,Se,ps,zo,vp,ms,_p,cn,me,Ep,cs,gp,xp,us,$p,Op,un,Fe,fs,Xo,hs,bp,qp,vs,Np,jp,M,Mo,Bo,_s,kp,Tp,Es,wp,Dp,gs,xs,Cp,Pp,Ro,So,$s,Lp,Ap,Os,yp,Ip,bs,qs,zp,Xp,Fo,Ns,js,Mp,Bp,ks,Ts,Rp,Sp,Vo,ws,Ds,Fp,Vp,Cs,Ps,Hp,Gp,Ho,Go,Ls,Up,Wp,As,Kp,Qp,ys,Is,Jp,Yp,Uo,zs,Xs,Zp,em,Ms,Bs,om,am,Wo,Rs,Ss,tm,sm,Fs,Vs,rm,fn,Ve,nm,Hs,lm,im,hn,Ko,vn,ce,dm,Gs,pm,mm,Us,cm,um,_n,Qo,En,Pa,fm,gn,Jo,xn,Z,hm,Ws,vm,_m,Ks,Em,gm,Qs,xm,$m,$n,He,On,Ge,bn,je,Ue,Js,Yo,Om,Ys,bm,qn,La,qm,Nn,ue,Zs,Nm,jm,er,km,Tm,or,wm,jn,Aa,Dm,kn,ke,We,ar,Zo,Cm,tr,Pm,Tn,ya,Lm,wn,fe,Ia,Am,sr,ym,Im,za,zm,rr,Xm,Mm,Xa,Bm,nr,Rm,Dn,Ke,Cn,Qe,Sm,lr,Fm,Vm,Pn,ea,Ln,V,Hm,ir,Gm,Um,dr,Wm,Km,pr,Qm,Jm,mr,Ym,Zm,An,Je,yn,Ma,ec,In,oa,zn,Ba,oc,Xn,aa,Mn,Ra,ac,Bn,ta,Rn,H,tc,cr,sc,rc,ur,nc,lc,fr,ic,dc,hr,pc,mc,Sn,sa,Fn,Ye,Vn,Te,Ze,vr,ra,cc,_r,uc,Hn,he,fc,Er,hc,vc,gr,_c,Ec,Gn,na,Un,R,gc,xr,xc,$c,$r,Oc,bc,Or,qc,Nc,br,jc,kc,qr,Tc,wc,Wn,la,Kn,eo,Qn,we,oo,Nr,ia,Dc,jr,Cc,Jn,ve,Pc,kr,Lc,Ac,Tr,yc,Ic,Yn,da,Zn,ao,zc,wr,Xc,Mc,el,De,to,Dr,pa,Bc,Cr,Rc,ol,Sa,Sc,al,_e,ma,Fc,Pr,Vc,Hc,Gc,Fa,Uc,Lr,Wc,Kc,Va,Qc,Ar,Jc,tl,so,Yc,ca,Zc,eu,sl;return v=new lo({}),W=new va({props:{$$slots:{default:[Dv]},$$scope:{ctx:B}}}),Oo=new lo({}),bo=new z({props:{code:"pip install transformers[onnx]",highlighted:"pip install transformers[onnx]"}}),qo=new z({props:{code:`python -m transformers.onnx --help

usage: Hugging Face Transformers ONNX exporter [-h] -m MODEL [--feature {causal-lm, ...}] [--opset OPSET] [--atol ATOL] output

positional arguments:
  output                Path indicating where to store generated ONNX model.

optional arguments:
  -h, --help            show this help message and exit
  -m MODEL, --model MODEL
                        Model ID on huggingface.co or path on disk to load model from.
  --feature {causal-lm, ...}
                        The type of features to export the model with.
  --opset OPSET         ONNX opset version to export the model with.
  --atol ATOL           Absolute difference tolerance when validating the model.`,highlighted:`python -m transformers.onnx --<span class="hljs-built_in">help</span>

usage: Hugging Face Transformers ONNX exporter [-h] -m MODEL [--feature {causal-lm, ...}] [--opset OPSET] [--atol ATOL] output

positional arguments:
  output                Path indicating <span class="hljs-built_in">where</span> to store generated ONNX model.

optional arguments:
  -h, --<span class="hljs-built_in">help</span>            show this <span class="hljs-built_in">help</span> message and <span class="hljs-built_in">exit</span>
  -m MODEL, --model MODEL
                        Model ID on huggingface.co or path on disk to load model from.
  --feature {causal-lm, ...}
                        The <span class="hljs-built_in">type</span> of features to <span class="hljs-built_in">export</span> the model with.
  --opset OPSET         ONNX opset version to <span class="hljs-built_in">export</span> the model with.
  --atol ATOL           Absolute difference tolerance when validating the model.`}}),No=new z({props:{code:"python -m transformers.onnx --model=distilbert-base-uncased onnx/",highlighted:"python -m transformers.onnx --model=distilbert-base-uncased onnx/"}}),jo=new z({props:{code:`Validating ONNX model...
        -[\u2713] ONNX model output names match reference model ({'last_hidden_state'})
        - Validating ONNX Model output "last_hidden_state":
                -[\u2713] (2, 8, 768) matches (2, 8, 768)
                -[\u2713] all values close (atol: 1e-05)
All good, model saved at: onnx/model.onnx`,highlighted:`Validating ONNX model...
        -[\u2713] ONNX model output names match reference model ({<span class="hljs-string">&#x27;last_hidden_state&#x27;</span>})
        - Validating ONNX Model output <span class="hljs-string">&quot;last_hidden_state&quot;</span>:
                -[\u2713] (2, 8, 768) matches (2, 8, 768)
                -[\u2713] all values close (atol: 1e-05)
All good, model saved at: onnx/model.onnx`}}),wo=new z({props:{code:`from transformers import AutoTokenizer
from onnxruntime import InferenceSession

tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
session = InferenceSession("onnx/model.onnx")
# ONNX Runtime expects NumPy arrays as input
inputs = tokenizer("Using DistilBERT with ONNX Runtime!", return_tensors="np")
outputs = session.run(output_names=["last_hidden_state"], input_feed=dict(inputs))`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> onnxruntime <span class="hljs-keyword">import</span> InferenceSession

<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>session = InferenceSession(<span class="hljs-string">&quot;onnx/model.onnx&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># ONNX Runtime expects NumPy arrays as input</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>inputs = tokenizer(<span class="hljs-string">&quot;Using DistilBERT with ONNX Runtime!&quot;</span>, return_tensors=<span class="hljs-string">&quot;np&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>outputs = session.run(output_names=[<span class="hljs-string">&quot;last_hidden_state&quot;</span>], input_feed=<span class="hljs-built_in">dict</span>(inputs))`}}),Do=new z({props:{code:`from transformers.models.distilbert import DistilBertConfig, DistilBertOnnxConfig

config = DistilBertConfig()
onnx_config = DistilBertOnnxConfig(config)
print(list(onnx_config.outputs.keys()))`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers.models.distilbert <span class="hljs-keyword">import</span> DistilBertConfig, DistilBertOnnxConfig

<span class="hljs-meta">&gt;&gt;&gt; </span>config = DistilBertConfig()
<span class="hljs-meta">&gt;&gt;&gt; </span>onnx_config = DistilBertOnnxConfig(config)
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-built_in">print</span>(<span class="hljs-built_in">list</span>(onnx_config.outputs.keys()))
[<span class="hljs-string">&quot;last_hidden_state&quot;</span>]`}}),Po=new z({props:{code:"python -m transformers.onnx --model=keras-io/transformers-qa onnx/",highlighted:"python -m transformers.onnx --model=keras-io/transformers-qa onnx/"}}),Lo=new z({props:{code:`from transformers import AutoTokenizer, AutoModelForSequenceClassification

# Load tokenizer and PyTorch weights form the Hub
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
pt_model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")
# Save to disk
tokenizer.save_pretrained("local-pt-checkpoint")
pt_model.save_pretrained("local-pt-checkpoint")`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, AutoModelForSequenceClassification

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Load tokenizer and PyTorch weights form the Hub</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>pt_model = AutoModelForSequenceClassification.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Save to disk</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer.save_pretrained(<span class="hljs-string">&quot;local-pt-checkpoint&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>pt_model.save_pretrained(<span class="hljs-string">&quot;local-pt-checkpoint&quot;</span>)`}}),Ao=new z({props:{code:"python -m transformers.onnx --model=local-pt-checkpoint onnx/",highlighted:"python -m transformers.onnx --model=local-pt-checkpoint onnx/"}}),yo=new z({props:{code:`from transformers import AutoTokenizer, TFAutoModelForSequenceClassification

# Load tokenizer and TensorFlow weights from the Hub
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
tf_model = TFAutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")
# Save to disk
tokenizer.save_pretrained("local-tf-checkpoint")
tf_model.save_pretrained("local-tf-checkpoint")`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, TFAutoModelForSequenceClassification

<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Load tokenizer and TensorFlow weights from the Hub</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>tf_model = TFAutoModelForSequenceClassification.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Save to disk</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer.save_pretrained(<span class="hljs-string">&quot;local-tf-checkpoint&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>tf_model.save_pretrained(<span class="hljs-string">&quot;local-tf-checkpoint&quot;</span>)`}}),Io=new z({props:{code:"python -m transformers.onnx --model=local-tf-checkpoint onnx/",highlighted:"python -m transformers.onnx --model=local-tf-checkpoint onnx/"}}),zo=new lo({}),Ko=new z({props:{code:`from transformers.onnx.features import FeaturesManager

distilbert_features = list(FeaturesManager.get_supported_features_for_model_type("distilbert").keys())
print(distilbert_features)`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers.onnx.features <span class="hljs-keyword">import</span> FeaturesManager

<span class="hljs-meta">&gt;&gt;&gt; </span>distilbert_features = <span class="hljs-built_in">list</span>(FeaturesManager.get_supported_features_for_model_type(<span class="hljs-string">&quot;distilbert&quot;</span>).keys())
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-built_in">print</span>(distilbert_features)
[<span class="hljs-string">&quot;default&quot;</span>, <span class="hljs-string">&quot;masked-lm&quot;</span>, <span class="hljs-string">&quot;causal-lm&quot;</span>, <span class="hljs-string">&quot;sequence-classification&quot;</span>, <span class="hljs-string">&quot;token-classification&quot;</span>, <span class="hljs-string">&quot;question-answering&quot;</span>]`}}),Qo=new z({props:{code:`python -m transformers.onnx --model=distilbert-base-uncased-finetuned-sst-2-english \\
                            --feature=sequence-classification onnx/`,highlighted:`python -m transformers.onnx --model=distilbert-base-uncased-finetuned-sst-2-english \\
                            --feature=sequence-classification onnx/`}}),Jo=new z({props:{code:`Validating ONNX model...
        -[\u2713] ONNX model output names match reference model ({'logits'})
        - Validating ONNX Model output "logits":
                -[\u2713] (2, 2) matches (2, 2)
                -[\u2713] all values close (atol: 1e-05)
All good, model saved at: onnx/model.onnx`,highlighted:`Validating ONNX model...
        -[\u2713] ONNX model output names match reference model ({<span class="hljs-string">&#x27;logits&#x27;</span>})
        - Validating ONNX Model output <span class="hljs-string">&quot;logits&quot;</span>:
                -[\u2713] (2, 2) matches (2, 2)
                -[\u2713] all values close (atol: 1e-05)
All good, model saved at: onnx/model.onnx`}}),He=new va({props:{$$slots:{default:[Cv]},$$scope:{ctx:B}}}),Ge=new va({props:{$$slots:{default:[Pv]},$$scope:{ctx:B}}}),Yo=new lo({}),Zo=new lo({}),Ke=new va({props:{$$slots:{default:[Lv]},$$scope:{ctx:B}}}),ea=new z({props:{code:`from typing import Mapping, OrderedDict
from transformers.onnx import OnnxConfig


class DistilBertOnnxConfig(OnnxConfig):
    @property
    def inputs(self) -> Mapping[str, Mapping[int, str]]:
        return OrderedDict(
            [
                ("input_ids", {0: "batch", 1: "sequence"}),
                ("attention_mask", {0: "batch", 1: "sequence"}),
            ]
        )`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> typing <span class="hljs-keyword">import</span> Mapping, OrderedDict
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers.onnx <span class="hljs-keyword">import</span> OnnxConfig


<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">class</span> <span class="hljs-title class_">DistilBertOnnxConfig</span>(<span class="hljs-title class_ inherited__">OnnxConfig</span>):
<span class="hljs-meta">... </span>    @<span class="hljs-built_in">property</span>
<span class="hljs-meta">... </span>    <span class="hljs-keyword">def</span> <span class="hljs-title function_">inputs</span>(<span class="hljs-params">self</span>) -&gt; Mapping[<span class="hljs-built_in">str</span>, Mapping[<span class="hljs-built_in">int</span>, <span class="hljs-built_in">str</span>]]:
<span class="hljs-meta">... </span>        <span class="hljs-keyword">return</span> OrderedDict(
<span class="hljs-meta">... </span>            [
<span class="hljs-meta">... </span>                (<span class="hljs-string">&quot;input_ids&quot;</span>, {<span class="hljs-number">0</span>: <span class="hljs-string">&quot;batch&quot;</span>, <span class="hljs-number">1</span>: <span class="hljs-string">&quot;sequence&quot;</span>}),
<span class="hljs-meta">... </span>                (<span class="hljs-string">&quot;attention_mask&quot;</span>, {<span class="hljs-number">0</span>: <span class="hljs-string">&quot;batch&quot;</span>, <span class="hljs-number">1</span>: <span class="hljs-string">&quot;sequence&quot;</span>}),
<span class="hljs-meta">... </span>            ]
<span class="hljs-meta">... </span>        )`}}),Je=new va({props:{$$slots:{default:[Av]},$$scope:{ctx:B}}}),oa=new z({props:{code:`from transformers import AutoConfig

config = AutoConfig.from_pretrained("distilbert-base-uncased")
onnx_config = DistilBertOnnxConfig(config)`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoConfig

<span class="hljs-meta">&gt;&gt;&gt; </span>config = AutoConfig.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>onnx_config = DistilBertOnnxConfig(config)`}}),aa=new z({props:{code:"print(onnx_config.default_onnx_opset)",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-built_in">print</span>(onnx_config.default_onnx_opset)
<span class="hljs-number">11</span>`}}),ta=new z({props:{code:"print(onnx_config.outputs)",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-built_in">print</span>(onnx_config.outputs)
OrderedDict([(<span class="hljs-string">&quot;last_hidden_state&quot;</span>, {<span class="hljs-number">0</span>: <span class="hljs-string">&quot;batch&quot;</span>, <span class="hljs-number">1</span>: <span class="hljs-string">&quot;sequence&quot;</span>})])`}}),sa=new z({props:{code:`from transformers import AutoConfig

config = AutoConfig.from_pretrained("distilbert-base-uncased")
onnx_config_for_seq_clf = DistilBertOnnxConfig(config, task="sequence-classification")
print(onnx_config_for_seq_clf.outputs)`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoConfig

<span class="hljs-meta">&gt;&gt;&gt; </span>config = AutoConfig.from_pretrained(<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>onnx_config_for_seq_clf = DistilBertOnnxConfig(config, task=<span class="hljs-string">&quot;sequence-classification&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-built_in">print</span>(onnx_config_for_seq_clf.outputs)
OrderedDict([(<span class="hljs-string">&#x27;logits&#x27;</span>, {<span class="hljs-number">0</span>: <span class="hljs-string">&#x27;batch&#x27;</span>})])`}}),Ye=new va({props:{$$slots:{default:[yv]},$$scope:{ctx:B}}}),ra=new lo({}),na=new z({props:{code:`from pathlib import Path
from transformers.onnx import export
from transformers import AutoTokenizer, AutoModel

onnx_path = Path("model.onnx")
model_ckpt = "distilbert-base-uncased"
base_model = AutoModel.from_pretrained(model_ckpt)
tokenizer = AutoTokenizer.from_pretrained(model_ckpt)

onnx_inputs, onnx_outputs = export(tokenizer, base_model, onnx_config, onnx_config.default_onnx_opset, onnx_path)`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> pathlib <span class="hljs-keyword">import</span> Path
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers.onnx <span class="hljs-keyword">import</span> export
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, AutoModel

<span class="hljs-meta">&gt;&gt;&gt; </span>onnx_path = Path(<span class="hljs-string">&quot;model.onnx&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>model_ckpt = <span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>base_model = AutoModel.from_pretrained(model_ckpt)
<span class="hljs-meta">&gt;&gt;&gt; </span>tokenizer = AutoTokenizer.from_pretrained(model_ckpt)

<span class="hljs-meta">&gt;&gt;&gt; </span>onnx_inputs, onnx_outputs = export(tokenizer, base_model, onnx_config, onnx_config.default_onnx_opset, onnx_path)`}}),la=new z({props:{code:`import onnx

onnx_model = onnx.load("model.onnx")
onnx.checker.check_model(onnx_model)`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">import</span> onnx

<span class="hljs-meta">&gt;&gt;&gt; </span>onnx_model = onnx.load(<span class="hljs-string">&quot;model.onnx&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>onnx.checker.check_model(onnx_model)`}}),eo=new va({props:{$$slots:{default:[Iv]},$$scope:{ctx:B}}}),ia=new lo({}),da=new z({props:{code:`from transformers.onnx import validate_model_outputs

validate_model_outputs(
    onnx_config, tokenizer, base_model, onnx_path, onnx_outputs, onnx_config.atol_for_validation
)`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> transformers.onnx <span class="hljs-keyword">import</span> validate_model_outputs

<span class="hljs-meta">&gt;&gt;&gt; </span>validate_model_outputs(
<span class="hljs-meta">... </span>    onnx_config, tokenizer, base_model, onnx_path, onnx_outputs, onnx_config.atol_for_validation
<span class="hljs-meta">... </span>)`}}),pa=new lo({}),{c(){f=r("meta"),D=d(),h=r("h1"),N=r("a"),T=r("span"),g(v.$$.fragment),E=d(),C=r("span"),j=t("Exportando modelos para ONNX"),k=d(),A=r("p"),P=t(`Se voc\xEA precisar implantar modelos \u{1F917} Transformers em ambientes de produ\xE7\xE3o, recomendamos
exporta-los para um formato serializado que pode ser carregado e executado em
tempos de execu\xE7\xE3o e hardware. Neste guia, mostraremos como exportar modelos \u{1F917} Transformers
para `),w=r("a"),U=t("ONNX (Open Neural Network eXchange)"),S=t("."),F=d(),g(W.$$.fragment),re=d(),K=r("p"),io=t(`ONNX \xE9 um padr\xE3o aberto que define um conjunto comum de operadores e um formato de arquivo comum
para representar modelos de aprendizado profundo em uma ampla variedade de estruturas, incluindo PyTorch e
TensorFlow. Quando um modelo \xE9 exportado para o formato ONNX, esses operadores s\xE3o usados para
construir um grafo computacional (muitas vezes chamado de `),oe=r("em"),po=t("representa\xE7\xE3o intermedi\xE1ria"),mo=t(`) que
representa o fluxo de dados atrav\xE9s da rede neural.`),xe=d(),L=r("p"),co=t(`Ao expor um grafo com operadores e tipos de dados padronizados, o ONNX facilita a
alternar entre os frameworks. Por exemplo, um modelo treinado em PyTorch pode ser exportado para
formato ONNX e depois importado no TensorFlow (e vice-versa).`),ne=d(),Q=r("p"),uo=t("\u{1F917} Transformers fornece um pacote "),J=r("a"),$e=r("code"),fo=t("transformers.onnx"),Oe=t(` que permite
que voc\xEA converta os checkpoints do modelo em um grafo ONNX aproveitando os objetos de configura\xE7\xE3o.
Esses objetos de configura\xE7\xE3o v\xEAm prontos para v\xE1rias arquiteturas de modelo e s\xE3o
projetado para ser facilmente extens\xEDvel a outras arquiteturas.`),Ce=d(),le=r("p"),be=t("As configura\xE7\xF5es prontas incluem as seguintes arquiteturas:"),Pe=d(),c=r("ul"),ae=r("li"),ho=t("ALBERT"),vo=d(),te=r("li"),_o=t("BART"),Eo=d(),se=r("li"),go=t("BEiT"),xo=d(),X=r("li"),y=t("BERT"),_a=d(),Le=r("li"),Ea=t("BigBird"),ga=d(),Ae=r("li"),xa=t("BigBird-Pegasus"),$a=d(),I=r("li"),Oa=t("Blenderbot"),ba=d(),ye=r("li"),qa=t("BlenderbotSmall"),Na=d(),Ie=r("li"),ja=t("BLOOM"),yl=d(),ot=r("li"),Il=t("CamemBERT"),zl=d(),at=r("li"),Xl=t("CLIP"),Ml=d(),tt=r("li"),Bl=t("CodeGen"),Rl=d(),st=r("li"),Sl=t("Conditional DETR"),Fl=d(),rt=r("li"),Vl=t("ConvBERT"),Hl=d(),nt=r("li"),Gl=t("ConvNeXT"),Ul=d(),lt=r("li"),Wl=t("ConvNeXTV2"),Kl=d(),it=r("li"),Ql=t("Data2VecText"),Jl=d(),dt=r("li"),Yl=t("Data2VecVision"),Zl=d(),pt=r("li"),ei=t("DeBERTa"),oi=d(),mt=r("li"),ai=t("DeBERTa-v2"),ti=d(),ct=r("li"),si=t("DeiT"),ri=d(),ut=r("li"),ni=t("DETR"),li=d(),ft=r("li"),ii=t("DistilBERT"),di=d(),ht=r("li"),pi=t("ELECTRA"),mi=d(),vt=r("li"),ci=t("ERNIE"),ui=d(),_t=r("li"),fi=t("FlauBERT"),hi=d(),Et=r("li"),vi=t("GPT Neo"),_i=d(),gt=r("li"),Ei=t("GPT-J"),gi=d(),xt=r("li"),xi=t("GroupViT"),$i=d(),$t=r("li"),Oi=t("I-BERT"),bi=d(),Ot=r("li"),qi=t("LayoutLM"),Ni=d(),bt=r("li"),ji=t("LayoutLMv3"),ki=d(),qt=r("li"),Ti=t("LeViT"),wi=d(),Nt=r("li"),Di=t("Longformer"),Ci=d(),jt=r("li"),Pi=t("LongT5"),Li=d(),kt=r("li"),Ai=t("M2M100"),yi=d(),Tt=r("li"),Ii=t("Marian"),zi=d(),wt=r("li"),Xi=t("mBART"),Mi=d(),Dt=r("li"),Bi=t("MobileBERT"),Ri=d(),Ct=r("li"),Si=t("MobileViT"),Fi=d(),Pt=r("li"),Vi=t("MT5"),Hi=d(),Lt=r("li"),Gi=t("OpenAI GPT-2"),Ui=d(),At=r("li"),Wi=t("OWL-ViT"),Ki=d(),yt=r("li"),Qi=t("Perceiver"),Ji=d(),It=r("li"),Yi=t("PLBart"),Zi=d(),zt=r("li"),ed=t("ResNet"),od=d(),Xt=r("li"),ad=t("RoBERTa"),td=d(),Mt=r("li"),sd=t("RoFormer"),rd=d(),Bt=r("li"),nd=t("SegFormer"),ld=d(),Rt=r("li"),id=t("SqueezeBERT"),dd=d(),St=r("li"),pd=t("Swin Transformer"),md=d(),Ft=r("li"),cd=t("T5"),ud=d(),Vt=r("li"),fd=t("Table Transformer"),hd=d(),Ht=r("li"),vd=t("Vision Encoder decoder"),_d=d(),Gt=r("li"),Ed=t("ViT"),gd=d(),Ut=r("li"),xd=t("XLM"),$d=d(),Wt=r("li"),Od=t("XLM-RoBERTa"),bd=d(),Kt=r("li"),qd=t("XLM-RoBERTa-XL"),Nd=d(),Qt=r("li"),jd=t("YOLOS"),Mr=d(),ka=r("p"),kd=t("Nas pr\xF3ximas duas se\xE7\xF5es, mostraremos como:"),Br=d(),ze=r("ul"),$o=r("li"),Td=t("Exportar um modelo suportado usando o pacote "),Jt=r("code"),wd=t("transformers.onnx"),Dd=t("."),Cd=d(),Yt=r("li"),Pd=t("Exportar um modelo personalizado para uma arquitetura sem suporte."),Rr=d(),qe=r("h2"),Xe=r("a"),Zt=r("span"),g(Oo.$$.fragment),Ld=d(),es=r("span"),Ad=t("Exportando um modelo para ONNX"),Sr=d(),Ta=r("p"),yd=t(`Para exportar um modelo \u{1F917} Transformers para o ONNX, primeiro voc\xEA precisa instalar algumas
depend\xEAncias extras:`),Fr=d(),g(bo.$$.fragment),Vr=d(),Me=r("p"),Id=t("O pacote "),os=r("code"),zd=t("transformers.onnx"),Xd=t(" pode ent\xE3o ser usado como um m\xF3dulo Python:"),Hr=d(),g(qo.$$.fragment),Gr=d(),wa=r("p"),Md=t("A exporta\xE7\xE3o de um checkpoint usando uma configura\xE7\xE3o pronta pode ser feita da seguinte forma:"),Ur=d(),g(No.$$.fragment),Wr=d(),Da=r("p"),Bd=t("Voc\xEA deve ver os seguintes logs:"),Kr=d(),g(jo.$$.fragment),Qr=d(),ie=r("p"),Rd=t("Isso exporta um grafo ONNX do ponto de verifica\xE7\xE3o definido pelo argumento "),as=r("code"),Sd=t("--model"),Fd=t(`. Nisso
Por exemplo, \xE9 `),ts=r("code"),Vd=t("distilbert-base-uncased"),Hd=t(`, mas pode ser qualquer checkpoint no Hugging
Face Hub ou um armazenado localmente.`),Jr=d(),Y=r("p"),Gd=t("O arquivo "),ss=r("code"),Ud=t("model.onnx"),Wd=t(" resultante pode ser executado em um dos "),ko=r("a"),Kd=t(`muitos
aceleradores`),Qd=t(` que suportam o ONNX
padr\xE3o. Por exemplo, podemos carregar e executar o modelo com `),To=r("a"),Jd=t(`ONNX
Tempo de execu\xE7\xE3o`),Yd=t(" da seguinte forma:"),Yr=d(),g(wo.$$.fragment),Zr=d(),Be=r("p"),Zd=t("Os nomes de sa\xEDda necess\xE1rios (como "),rs=r("code"),ep=t('["last_hidden_state"]'),op=t(`) podem ser obtidos pegando uma
configura\xE7\xE3o ONNX de cada modelo. Por exemplo, para DistilBERT temos:`),en=d(),g(Do.$$.fragment),on=d(),Re=r("p"),ap=t(`O processo \xE9 id\xEAntico para os checkpoints do TensorFlow no Hub. Por exemplo, podemos
exportar um checkpoint TensorFlow puro do `),Co=r("a"),tp=t("Keras"),sp=t(" da seguinte forma:"),an=d(),g(Po.$$.fragment),tn=d(),Ca=r("p"),rp=t(`Para exportar um modelo armazenado localmente, voc\xEA precisar\xE1 ter os pesos e
arquivos tokenizer armazenados em um diret\xF3rio. Por exemplo, podemos carregar e salvar um checkpoint como:`),sn=d(),g(Lo.$$.fragment),rn=d(),de=r("p"),np=t("Uma vez que o checkpoint \xE9 salvo, podemos export\xE1-lo para o ONNX apontando o "),ns=r("code"),lp=t("--model"),ip=t(`
argumento do pacote `),ls=r("code"),dp=t("transformers.onnx"),pp=t(" para o diret\xF3rio desejado:"),nn=d(),g(Ao.$$.fragment),ln=d(),g(yo.$$.fragment),dn=d(),pe=r("p"),mp=t("Uma vez que o checkpoint \xE9 salvo, podemos export\xE1-lo para o ONNX apontando o "),is=r("code"),cp=t("--model"),up=t(`
argumento do pacote `),ds=r("code"),fp=t("transformers.onnx"),hp=t(" para o diret\xF3rio desejado:"),pn=d(),g(Io.$$.fragment),mn=d(),Ne=r("h2"),Se=r("a"),ps=r("span"),g(zo.$$.fragment),vp=d(),ms=r("span"),_p=t("Selecionando features para diferentes tarefas do modelo"),cn=d(),me=r("p"),Ep=t("Cada configura\xE7\xE3o pronta vem com um conjunto de "),cs=r("em"),gp=t("features"),xp=t(` que permitem exportar
modelos para diferentes tipos de tarefas. Conforme mostrado na tabela abaixo, cada recurso \xE9
associado a uma `),us=r("code"),$p=t("AutoClass"),Op=t(" diferente:"),un=d(),Fe=r("table"),fs=r("thead"),Xo=r("tr"),hs=r("th"),bp=t("Feature"),qp=d(),vs=r("th"),Np=t("Auto Class"),jp=d(),M=r("tbody"),Mo=r("tr"),Bo=r("td"),_s=r("code"),kp=t("causal-lm"),Tp=t(", "),Es=r("code"),wp=t("causal-lm-with-past"),Dp=d(),gs=r("td"),xs=r("code"),Cp=t("AutoModelForCausalLM"),Pp=d(),Ro=r("tr"),So=r("td"),$s=r("code"),Lp=t("default"),Ap=t(", "),Os=r("code"),yp=t("default-with-past"),Ip=d(),bs=r("td"),qs=r("code"),zp=t("AutoModel"),Xp=d(),Fo=r("tr"),Ns=r("td"),js=r("code"),Mp=t("masked-lm"),Bp=d(),ks=r("td"),Ts=r("code"),Rp=t("AutoModelForMaskedLM"),Sp=d(),Vo=r("tr"),ws=r("td"),Ds=r("code"),Fp=t("question-answering"),Vp=d(),Cs=r("td"),Ps=r("code"),Hp=t("AutoModelForQuestionAnswering"),Gp=d(),Ho=r("tr"),Go=r("td"),Ls=r("code"),Up=t("seq2seq-lm"),Wp=t(", "),As=r("code"),Kp=t("seq2seq-lm-with-past"),Qp=d(),ys=r("td"),Is=r("code"),Jp=t("AutoModelForSeq2SeqLM"),Yp=d(),Uo=r("tr"),zs=r("td"),Xs=r("code"),Zp=t("sequence-classification"),em=d(),Ms=r("td"),Bs=r("code"),om=t("AutoModelForSequenceClassification"),am=d(),Wo=r("tr"),Rs=r("td"),Ss=r("code"),tm=t("token-classification"),sm=d(),Fs=r("td"),Vs=r("code"),rm=t("AutoModelForTokenClassification"),fn=d(),Ve=r("p"),nm=t(`Para cada configura\xE7\xE3o, voc\xEA pode encontrar a lista de recursos suportados por meio do
`),Hs=r("code"),lm=t("FeaturesManager"),im=t(". Por exemplo, para DistilBERT temos:"),hn=d(),g(Ko.$$.fragment),vn=d(),ce=r("p"),dm=t("Voc\xEA pode ent\xE3o passar um desses recursos para o argumento "),Gs=r("code"),pm=t("--feature"),mm=t(` no
pacote `),Us=r("code"),cm=t("transformers.onnx"),um=t(`. Por exemplo, para exportar um modelo de classifica\xE7\xE3o de texto, podemos
escolher um modelo ajustado no Hub e executar:`),_n=d(),g(Qo.$$.fragment),En=d(),Pa=r("p"),fm=t("Isso exibe os seguintes logs:"),gn=d(),g(Jo.$$.fragment),xn=d(),Z=r("p"),hm=t("Observe que, neste caso, os nomes de sa\xEDda do modelo ajustado s\xE3o "),Ws=r("code"),vm=t("logits"),_m=t(`
em vez do `),Ks=r("code"),Em=t("last_hidden_state"),gm=t(" que vimos com o checkpoint "),Qs=r("code"),xm=t("distilbert-base-uncased"),$m=t(`
mais cedo. Isso \xE9 esperado, pois o modelo ajustado (fine-tuned) possui uma cabe\xE7a de classifica\xE7\xE3o de sequ\xEAncia.`),$n=d(),g(He.$$.fragment),On=d(),g(Ge.$$.fragment),bn=d(),je=r("h2"),Ue=r("a"),Js=r("span"),g(Yo.$$.fragment),Om=d(),Ys=r("span"),bm=t("Exportando um modelo para uma arquitetura sem suporte"),qn=d(),La=r("p"),qm=t(`Se voc\xEA deseja exportar um modelo cuja arquitetura n\xE3o \xE9 suportada nativamente pela
biblioteca, h\xE1 tr\xEAs etapas principais a seguir:`),Nn=d(),ue=r("ol"),Zs=r("li"),Nm=t("Implemente uma configura\xE7\xE3o ONNX personalizada."),jm=d(),er=r("li"),km=t("Exporte o modelo para o ONNX."),Tm=d(),or=r("li"),wm=t("Valide as sa\xEDdas do PyTorch e dos modelos exportados."),jn=d(),Aa=r("p"),Dm=t(`Nesta se\xE7\xE3o, veremos como o DistilBERT foi implementado para mostrar o que est\xE1 envolvido
em cada passo.`),kn=d(),ke=r("h3"),We=r("a"),ar=r("span"),g(Zo.$$.fragment),Cm=d(),tr=r("span"),Pm=t("Implementando uma configura\xE7\xE3o ONNX personalizada"),Tn=d(),ya=r("p"),Lm=t(`Vamos come\xE7ar com o objeto de configura\xE7\xE3o ONNX. Fornecemos tr\xEAs classes abstratas que
voc\xEA deve herdar, dependendo do tipo de arquitetura de modelo que deseja exportar:`),wn=d(),fe=r("ul"),Ia=r("li"),Am=t("Modelos baseados em codificador herdam de "),sr=r("code"),ym=t("OnnxConfig"),Im=d(),za=r("li"),zm=t("Modelos baseados em decodificador herdam de "),rr=r("code"),Xm=t("OnnxConfigWithPast"),Mm=d(),Xa=r("li"),Bm=t("Os modelos codificador-decodificador herdam de "),nr=r("code"),Rm=t("OnnxSeq2SeqConfigWithPast"),Dn=d(),g(Ke.$$.fragment),Cn=d(),Qe=r("p"),Sm=t(`Como o DistilBERT \xE9 um modelo baseado em codificador, sua configura\xE7\xE3o \xE9 herdada de
`),lr=r("code"),Fm=t("OnnxConfig"),Vm=t(":"),Pn=d(),g(ea.$$.fragment),Ln=d(),V=r("p"),Hm=t("Todo objeto de configura\xE7\xE3o deve implementar a propriedade "),ir=r("code"),Gm=t("inputs"),Um=t(` e retornar um mapeamento,
onde cada chave corresponde a uma entrada esperada e cada valor indica o eixo
dessa entrada. Para o DistilBERT, podemos ver que duas entradas s\xE3o necess\xE1rias: `),dr=r("code"),Wm=t("input_ids"),Km=t(` e
`),pr=r("code"),Qm=t("attention_mask"),Jm=t(". Essas entradas t\xEAm a mesma forma de "),mr=r("code"),Ym=t("(batch_size, sequence_length)"),Zm=t(`
\xE9 por isso que vemos os mesmos eixos usados na configura\xE7\xE3o.`),An=d(),g(Je.$$.fragment),yn=d(),Ma=r("p"),ec=t(`Depois de implementar uma configura\xE7\xE3o ONNX, voc\xEA pode instanci\xE1-la fornecendo a
configura\xE7\xE3o do modelo base da seguinte forma:`),In=d(),g(oa.$$.fragment),zn=d(),Ba=r("p"),oc=t(`O objeto resultante tem v\xE1rias propriedades \xFAteis. Por exemplo, voc\xEA pode visualizar o conjunto de operadores ONNX
que ser\xE1 usado durante a exporta\xE7\xE3o:`),Xn=d(),g(aa.$$.fragment),Mn=d(),Ra=r("p"),ac=t("Voc\xEA tamb\xE9m pode visualizar as sa\xEDdas associadas ao modelo da seguinte forma:"),Bn=d(),g(ta.$$.fragment),Rn=d(),H=r("p"),tc=t(`Observe que a propriedade outputs segue a mesma estrutura das entradas; ele retorna um
`),cr=r("code"),sc=t("OrderedDict"),rc=t(` de sa\xEDdas nomeadas e suas formas. A estrutura de sa\xEDda est\xE1 ligada a
escolha do recurso com o qual a configura\xE7\xE3o \xE9 inicializada. Por padr\xE3o, a configura\xE7\xE3o do ONNX
\xE9 inicializada com o recurso `),ur=r("code"),nc=t("default"),lc=t(` que corresponde \xE0 exporta\xE7\xE3o de um
modelo carregado com a classe `),fr=r("code"),ic=t("AutoModel"),dc=t(`. Se voc\xEA deseja exportar um modelo para outra tarefa,
apenas forne\xE7a um recurso diferente para o argumento `),hr=r("code"),pc=t("task"),mc=t(` quando voc\xEA inicializar a configura\xE7\xE3o ONNX
. Por exemplo, se quisermos exportar o DistilBERT com uma sequ\xEAncia
de classifica\xE7\xE3o, poder\xEDamos usar:`),Sn=d(),g(sa.$$.fragment),Fn=d(),g(Ye.$$.fragment),Vn=d(),Te=r("h3"),Ze=r("a"),vr=r("span"),g(ra.$$.fragment),cc=d(),_r=r("span"),uc=t("Exportando um modelo"),Hn=d(),he=r("p"),fc=t(`Depois de ter implementado a configura\xE7\xE3o do ONNX, o pr\xF3ximo passo \xE9 exportar o modelo.
Aqui podemos usar a fun\xE7\xE3o `),Er=r("code"),hc=t("export()"),vc=t(" fornecida pelo pacote "),gr=r("code"),_c=t("transformers.onnx"),Ec=t(`.
Esta fun\xE7\xE3o espera a configura\xE7\xE3o do ONNX, juntamente com o modelo base e o tokenizer,
e o caminho para salvar o arquivo exportado:`),Gn=d(),g(na.$$.fragment),Un=d(),R=r("p"),gc=t("Os "),xr=r("code"),xc=t("onnx_inputs"),$c=t(" e "),$r=r("code"),Oc=t("onnx_outputs"),bc=t(" retornados pela fun\xE7\xE3o "),Or=r("code"),qc=t("export()"),Nc=t(` s\xE3o listas de
chaves definidas nas propriedades `),br=r("code"),jc=t("inputs"),kc=t(" e "),qr=r("code"),Tc=t("outputs"),wc=t(` da configura\xE7\xE3o. Uma vez que o
modelo \xE9 exportado, voc\xEA pode testar se o modelo est\xE1 bem formado da seguinte forma:`),Wn=d(),g(la.$$.fragment),Kn=d(),g(eo.$$.fragment),Qn=d(),we=r("h3"),oo=r("a"),Nr=r("span"),g(ia.$$.fragment),Dc=d(),jr=r("span"),Cc=t("Validando a sa\xEDda dos modelos"),Jn=d(),ve=r("p"),Pc=t(`A etapa final \xE9 validar se as sa\xEDdas do modelo base e exportado concordam
dentro de alguma toler\xE2ncia absoluta. Aqui podemos usar a fun\xE7\xE3o `),kr=r("code"),Lc=t("validate_model_outputs()"),Ac=t(`
fornecida pelo pacote `),Tr=r("code"),yc=t("transformers.onnx"),Ic=t(" da seguinte forma:"),Yn=d(),g(da.$$.fragment),Zn=d(),ao=r("p"),zc=t("Esta fun\xE7\xE3o usa o m\xE9todo "),wr=r("code"),Xc=t("generate_dummy_inputs()"),Mc=t(` para
gerar entradas para o modelo base e o exportado, e a toler\xE2ncia absoluta pode ser
definida na configura\xE7\xE3o. Geralmente encontramos concord\xE2ncia num\xE9rica em 1e-6 a 1e-4
de alcance, embora qualquer coisa menor que 1e-3 provavelmente esteja OK.`),el=d(),De=r("h2"),to=r("a"),Dr=r("span"),g(pa.$$.fragment),Bc=d(),Cr=r("span"),Rc=t("Contribuindo com uma nova configura\xE7\xE3o para \u{1F917} Transformers"),ol=d(),Sa=r("p"),Sc=t(`Estamos procurando expandir o conjunto de configura\xE7\xF5es prontas e receber contribui\xE7\xF5es
da comunidade! Se voc\xEA gostaria de contribuir para a biblioteca, voc\xEA
precisar\xE1:`),al=d(),_e=r("ul"),ma=r("li"),Fc=t("Implemente a configura\xE7\xE3o do ONNX no arquivo "),Pr=r("code"),Vc=t("configuration_<model_name>.py"),Hc=t(` correspondente
Arquivo`),Gc=d(),Fa=r("li"),Uc=t(`Incluir a arquitetura do modelo e recursos correspondentes em
`),Lr=r("code"),Wc=t("~onnx.features.FeatureManager"),Kc=d(),Va=r("li"),Qc=t("Adicione sua arquitetura de modelo aos testes em "),Ar=r("code"),Jc=t("test_onnx_v2.py"),tl=d(),so=r("p"),Yc=t("Confira como ficou a configura\xE7\xE3o do "),ca=r("a"),Zc=t("IBERT"),eu=t(` para obter uma
id\xE9ia do que est\xE1 envolvido.`),this.h()},l(o){const i=Tv('[data-svelte="svelte-1phssyn"]',document.head);f=n(i,"META",{name:!0,content:!0}),i.forEach(a),D=p(o),h=n(o,"H1",{class:!0});var ua=l(h);N=n(ua,"A",{id:!0,class:!0,href:!0});var yr=l(N);T=n(yr,"SPAN",{});var Ir=l(T);x(v.$$.fragment,Ir),Ir.forEach(a),yr.forEach(a),E=p(ua),C=n(ua,"SPAN",{});var zr=l(C);j=s(zr,"Exportando modelos para ONNX"),zr.forEach(a),ua.forEach(a),k=p(o),A=n(o,"P",{});var fa=l(A);P=s(fa,`Se voc\xEA precisar implantar modelos \u{1F917} Transformers em ambientes de produ\xE7\xE3o, recomendamos
exporta-los para um formato serializado que pode ser carregado e executado em
tempos de execu\xE7\xE3o e hardware. Neste guia, mostraremos como exportar modelos \u{1F917} Transformers
para `),w=n(fa,"A",{href:!0,rel:!0});var Xr=l(w);U=s(Xr,"ONNX (Open Neural Network eXchange)"),Xr.forEach(a),S=s(fa,"."),fa.forEach(a),F=p(o),x(W.$$.fragment,o),re=p(o),K=n(o,"P",{});var ha=l(K);io=s(ha,`ONNX \xE9 um padr\xE3o aberto que define um conjunto comum de operadores e um formato de arquivo comum
para representar modelos de aprendizado profundo em uma ampla variedade de estruturas, incluindo PyTorch e
TensorFlow. Quando um modelo \xE9 exportado para o formato ONNX, esses operadores s\xE3o usados para
construir um grafo computacional (muitas vezes chamado de `),oe=n(ha,"EM",{});var nu=l(oe);po=s(nu,"representa\xE7\xE3o intermedi\xE1ria"),nu.forEach(a),mo=s(ha,`) que
representa o fluxo de dados atrav\xE9s da rede neural.`),ha.forEach(a),xe=p(o),L=n(o,"P",{});var lu=l(L);co=s(lu,`Ao expor um grafo com operadores e tipos de dados padronizados, o ONNX facilita a
alternar entre os frameworks. Por exemplo, um modelo treinado em PyTorch pode ser exportado para
formato ONNX e depois importado no TensorFlow (e vice-versa).`),lu.forEach(a),ne=p(o),Q=n(o,"P",{});var rl=l(Q);uo=s(rl,"\u{1F917} Transformers fornece um pacote "),J=n(rl,"A",{href:!0});var iu=l(J);$e=n(iu,"CODE",{});var du=l($e);fo=s(du,"transformers.onnx"),du.forEach(a),iu.forEach(a),Oe=s(rl,` que permite
que voc\xEA converta os checkpoints do modelo em um grafo ONNX aproveitando os objetos de configura\xE7\xE3o.
Esses objetos de configura\xE7\xE3o v\xEAm prontos para v\xE1rias arquiteturas de modelo e s\xE3o
projetado para ser facilmente extens\xEDvel a outras arquiteturas.`),rl.forEach(a),Ce=p(o),le=n(o,"P",{});var pu=l(le);be=s(pu,"As configura\xE7\xF5es prontas incluem as seguintes arquiteturas:"),pu.forEach(a),Pe=p(o),c=n(o,"UL",{});var u=l(c);ae=n(u,"LI",{});var mu=l(ae);ho=s(mu,"ALBERT"),mu.forEach(a),vo=p(u),te=n(u,"LI",{});var cu=l(te);_o=s(cu,"BART"),cu.forEach(a),Eo=p(u),se=n(u,"LI",{});var uu=l(se);go=s(uu,"BEiT"),uu.forEach(a),xo=p(u),X=n(u,"LI",{});var fu=l(X);y=s(fu,"BERT"),fu.forEach(a),_a=p(u),Le=n(u,"LI",{});var hu=l(Le);Ea=s(hu,"BigBird"),hu.forEach(a),ga=p(u),Ae=n(u,"LI",{});var vu=l(Ae);xa=s(vu,"BigBird-Pegasus"),vu.forEach(a),$a=p(u),I=n(u,"LI",{});var _u=l(I);Oa=s(_u,"Blenderbot"),_u.forEach(a),ba=p(u),ye=n(u,"LI",{});var Eu=l(ye);qa=s(Eu,"BlenderbotSmall"),Eu.forEach(a),Na=p(u),Ie=n(u,"LI",{});var gu=l(Ie);ja=s(gu,"BLOOM"),gu.forEach(a),yl=p(u),ot=n(u,"LI",{});var xu=l(ot);Il=s(xu,"CamemBERT"),xu.forEach(a),zl=p(u),at=n(u,"LI",{});var $u=l(at);Xl=s($u,"CLIP"),$u.forEach(a),Ml=p(u),tt=n(u,"LI",{});var Ou=l(tt);Bl=s(Ou,"CodeGen"),Ou.forEach(a),Rl=p(u),st=n(u,"LI",{});var bu=l(st);Sl=s(bu,"Conditional DETR"),bu.forEach(a),Fl=p(u),rt=n(u,"LI",{});var qu=l(rt);Vl=s(qu,"ConvBERT"),qu.forEach(a),Hl=p(u),nt=n(u,"LI",{});var Nu=l(nt);Gl=s(Nu,"ConvNeXT"),Nu.forEach(a),Ul=p(u),lt=n(u,"LI",{});var ju=l(lt);Wl=s(ju,"ConvNeXTV2"),ju.forEach(a),Kl=p(u),it=n(u,"LI",{});var ku=l(it);Ql=s(ku,"Data2VecText"),ku.forEach(a),Jl=p(u),dt=n(u,"LI",{});var Tu=l(dt);Yl=s(Tu,"Data2VecVision"),Tu.forEach(a),Zl=p(u),pt=n(u,"LI",{});var wu=l(pt);ei=s(wu,"DeBERTa"),wu.forEach(a),oi=p(u),mt=n(u,"LI",{});var Du=l(mt);ai=s(Du,"DeBERTa-v2"),Du.forEach(a),ti=p(u),ct=n(u,"LI",{});var Cu=l(ct);si=s(Cu,"DeiT"),Cu.forEach(a),ri=p(u),ut=n(u,"LI",{});var Pu=l(ut);ni=s(Pu,"DETR"),Pu.forEach(a),li=p(u),ft=n(u,"LI",{});var Lu=l(ft);ii=s(Lu,"DistilBERT"),Lu.forEach(a),di=p(u),ht=n(u,"LI",{});var Au=l(ht);pi=s(Au,"ELECTRA"),Au.forEach(a),mi=p(u),vt=n(u,"LI",{});var yu=l(vt);ci=s(yu,"ERNIE"),yu.forEach(a),ui=p(u),_t=n(u,"LI",{});var Iu=l(_t);fi=s(Iu,"FlauBERT"),Iu.forEach(a),hi=p(u),Et=n(u,"LI",{});var zu=l(Et);vi=s(zu,"GPT Neo"),zu.forEach(a),_i=p(u),gt=n(u,"LI",{});var Xu=l(gt);Ei=s(Xu,"GPT-J"),Xu.forEach(a),gi=p(u),xt=n(u,"LI",{});var Mu=l(xt);xi=s(Mu,"GroupViT"),Mu.forEach(a),$i=p(u),$t=n(u,"LI",{});var Bu=l($t);Oi=s(Bu,"I-BERT"),Bu.forEach(a),bi=p(u),Ot=n(u,"LI",{});var Ru=l(Ot);qi=s(Ru,"LayoutLM"),Ru.forEach(a),Ni=p(u),bt=n(u,"LI",{});var Su=l(bt);ji=s(Su,"LayoutLMv3"),Su.forEach(a),ki=p(u),qt=n(u,"LI",{});var Fu=l(qt);Ti=s(Fu,"LeViT"),Fu.forEach(a),wi=p(u),Nt=n(u,"LI",{});var Vu=l(Nt);Di=s(Vu,"Longformer"),Vu.forEach(a),Ci=p(u),jt=n(u,"LI",{});var Hu=l(jt);Pi=s(Hu,"LongT5"),Hu.forEach(a),Li=p(u),kt=n(u,"LI",{});var Gu=l(kt);Ai=s(Gu,"M2M100"),Gu.forEach(a),yi=p(u),Tt=n(u,"LI",{});var Uu=l(Tt);Ii=s(Uu,"Marian"),Uu.forEach(a),zi=p(u),wt=n(u,"LI",{});var Wu=l(wt);Xi=s(Wu,"mBART"),Wu.forEach(a),Mi=p(u),Dt=n(u,"LI",{});var Ku=l(Dt);Bi=s(Ku,"MobileBERT"),Ku.forEach(a),Ri=p(u),Ct=n(u,"LI",{});var Qu=l(Ct);Si=s(Qu,"MobileViT"),Qu.forEach(a),Fi=p(u),Pt=n(u,"LI",{});var Ju=l(Pt);Vi=s(Ju,"MT5"),Ju.forEach(a),Hi=p(u),Lt=n(u,"LI",{});var Yu=l(Lt);Gi=s(Yu,"OpenAI GPT-2"),Yu.forEach(a),Ui=p(u),At=n(u,"LI",{});var Zu=l(At);Wi=s(Zu,"OWL-ViT"),Zu.forEach(a),Ki=p(u),yt=n(u,"LI",{});var ef=l(yt);Qi=s(ef,"Perceiver"),ef.forEach(a),Ji=p(u),It=n(u,"LI",{});var of=l(It);Yi=s(of,"PLBart"),of.forEach(a),Zi=p(u),zt=n(u,"LI",{});var af=l(zt);ed=s(af,"ResNet"),af.forEach(a),od=p(u),Xt=n(u,"LI",{});var tf=l(Xt);ad=s(tf,"RoBERTa"),tf.forEach(a),td=p(u),Mt=n(u,"LI",{});var sf=l(Mt);sd=s(sf,"RoFormer"),sf.forEach(a),rd=p(u),Bt=n(u,"LI",{});var rf=l(Bt);nd=s(rf,"SegFormer"),rf.forEach(a),ld=p(u),Rt=n(u,"LI",{});var nf=l(Rt);id=s(nf,"SqueezeBERT"),nf.forEach(a),dd=p(u),St=n(u,"LI",{});var lf=l(St);pd=s(lf,"Swin Transformer"),lf.forEach(a),md=p(u),Ft=n(u,"LI",{});var df=l(Ft);cd=s(df,"T5"),df.forEach(a),ud=p(u),Vt=n(u,"LI",{});var pf=l(Vt);fd=s(pf,"Table Transformer"),pf.forEach(a),hd=p(u),Ht=n(u,"LI",{});var mf=l(Ht);vd=s(mf,"Vision Encoder decoder"),mf.forEach(a),_d=p(u),Gt=n(u,"LI",{});var cf=l(Gt);Ed=s(cf,"ViT"),cf.forEach(a),gd=p(u),Ut=n(u,"LI",{});var uf=l(Ut);xd=s(uf,"XLM"),uf.forEach(a),$d=p(u),Wt=n(u,"LI",{});var ff=l(Wt);Od=s(ff,"XLM-RoBERTa"),ff.forEach(a),bd=p(u),Kt=n(u,"LI",{});var hf=l(Kt);qd=s(hf,"XLM-RoBERTa-XL"),hf.forEach(a),Nd=p(u),Qt=n(u,"LI",{});var vf=l(Qt);jd=s(vf,"YOLOS"),vf.forEach(a),u.forEach(a),Mr=p(o),ka=n(o,"P",{});var _f=l(ka);kd=s(_f,"Nas pr\xF3ximas duas se\xE7\xF5es, mostraremos como:"),_f.forEach(a),Br=p(o),ze=n(o,"UL",{});var nl=l(ze);$o=n(nl,"LI",{});var ll=l($o);Td=s(ll,"Exportar um modelo suportado usando o pacote "),Jt=n(ll,"CODE",{});var Ef=l(Jt);wd=s(Ef,"transformers.onnx"),Ef.forEach(a),Dd=s(ll,"."),ll.forEach(a),Cd=p(nl),Yt=n(nl,"LI",{});var gf=l(Yt);Pd=s(gf,"Exportar um modelo personalizado para uma arquitetura sem suporte."),gf.forEach(a),nl.forEach(a),Rr=p(o),qe=n(o,"H2",{class:!0});var il=l(qe);Xe=n(il,"A",{id:!0,class:!0,href:!0});var xf=l(Xe);Zt=n(xf,"SPAN",{});var $f=l(Zt);x(Oo.$$.fragment,$f),$f.forEach(a),xf.forEach(a),Ld=p(il),es=n(il,"SPAN",{});var Of=l(es);Ad=s(Of,"Exportando um modelo para ONNX"),Of.forEach(a),il.forEach(a),Sr=p(o),Ta=n(o,"P",{});var bf=l(Ta);yd=s(bf,`Para exportar um modelo \u{1F917} Transformers para o ONNX, primeiro voc\xEA precisa instalar algumas
depend\xEAncias extras:`),bf.forEach(a),Fr=p(o),x(bo.$$.fragment,o),Vr=p(o),Me=n(o,"P",{});var dl=l(Me);Id=s(dl,"O pacote "),os=n(dl,"CODE",{});var qf=l(os);zd=s(qf,"transformers.onnx"),qf.forEach(a),Xd=s(dl," pode ent\xE3o ser usado como um m\xF3dulo Python:"),dl.forEach(a),Hr=p(o),x(qo.$$.fragment,o),Gr=p(o),wa=n(o,"P",{});var Nf=l(wa);Md=s(Nf,"A exporta\xE7\xE3o de um checkpoint usando uma configura\xE7\xE3o pronta pode ser feita da seguinte forma:"),Nf.forEach(a),Ur=p(o),x(No.$$.fragment,o),Wr=p(o),Da=n(o,"P",{});var jf=l(Da);Bd=s(jf,"Voc\xEA deve ver os seguintes logs:"),jf.forEach(a),Kr=p(o),x(jo.$$.fragment,o),Qr=p(o),ie=n(o,"P",{});var Ha=l(ie);Rd=s(Ha,"Isso exporta um grafo ONNX do ponto de verifica\xE7\xE3o definido pelo argumento "),as=n(Ha,"CODE",{});var kf=l(as);Sd=s(kf,"--model"),kf.forEach(a),Fd=s(Ha,`. Nisso
Por exemplo, \xE9 `),ts=n(Ha,"CODE",{});var Tf=l(ts);Vd=s(Tf,"distilbert-base-uncased"),Tf.forEach(a),Hd=s(Ha,`, mas pode ser qualquer checkpoint no Hugging
Face Hub ou um armazenado localmente.`),Ha.forEach(a),Jr=p(o),Y=n(o,"P",{});var ro=l(Y);Gd=s(ro,"O arquivo "),ss=n(ro,"CODE",{});var wf=l(ss);Ud=s(wf,"model.onnx"),wf.forEach(a),Wd=s(ro," resultante pode ser executado em um dos "),ko=n(ro,"A",{href:!0,rel:!0});var Df=l(ko);Kd=s(Df,`muitos
aceleradores`),Df.forEach(a),Qd=s(ro,` que suportam o ONNX
padr\xE3o. Por exemplo, podemos carregar e executar o modelo com `),To=n(ro,"A",{href:!0,rel:!0});var Cf=l(To);Jd=s(Cf,`ONNX
Tempo de execu\xE7\xE3o`),Cf.forEach(a),Yd=s(ro," da seguinte forma:"),ro.forEach(a),Yr=p(o),x(wo.$$.fragment,o),Zr=p(o),Be=n(o,"P",{});var pl=l(Be);Zd=s(pl,"Os nomes de sa\xEDda necess\xE1rios (como "),rs=n(pl,"CODE",{});var Pf=l(rs);ep=s(Pf,'["last_hidden_state"]'),Pf.forEach(a),op=s(pl,`) podem ser obtidos pegando uma
configura\xE7\xE3o ONNX de cada modelo. Por exemplo, para DistilBERT temos:`),pl.forEach(a),en=p(o),x(Do.$$.fragment,o),on=p(o),Re=n(o,"P",{});var ml=l(Re);ap=s(ml,`O processo \xE9 id\xEAntico para os checkpoints do TensorFlow no Hub. Por exemplo, podemos
exportar um checkpoint TensorFlow puro do `),Co=n(ml,"A",{href:!0,rel:!0});var Lf=l(Co);tp=s(Lf,"Keras"),Lf.forEach(a),sp=s(ml," da seguinte forma:"),ml.forEach(a),an=p(o),x(Po.$$.fragment,o),tn=p(o),Ca=n(o,"P",{});var Af=l(Ca);rp=s(Af,`Para exportar um modelo armazenado localmente, voc\xEA precisar\xE1 ter os pesos e
arquivos tokenizer armazenados em um diret\xF3rio. Por exemplo, podemos carregar e salvar um checkpoint como:`),Af.forEach(a),sn=p(o),x(Lo.$$.fragment,o),rn=p(o),de=n(o,"P",{});var Ga=l(de);np=s(Ga,"Uma vez que o checkpoint \xE9 salvo, podemos export\xE1-lo para o ONNX apontando o "),ns=n(Ga,"CODE",{});var yf=l(ns);lp=s(yf,"--model"),yf.forEach(a),ip=s(Ga,`
argumento do pacote `),ls=n(Ga,"CODE",{});var If=l(ls);dp=s(If,"transformers.onnx"),If.forEach(a),pp=s(Ga," para o diret\xF3rio desejado:"),Ga.forEach(a),nn=p(o),x(Ao.$$.fragment,o),ln=p(o),x(yo.$$.fragment,o),dn=p(o),pe=n(o,"P",{});var Ua=l(pe);mp=s(Ua,"Uma vez que o checkpoint \xE9 salvo, podemos export\xE1-lo para o ONNX apontando o "),is=n(Ua,"CODE",{});var zf=l(is);cp=s(zf,"--model"),zf.forEach(a),up=s(Ua,`
argumento do pacote `),ds=n(Ua,"CODE",{});var Xf=l(ds);fp=s(Xf,"transformers.onnx"),Xf.forEach(a),hp=s(Ua," para o diret\xF3rio desejado:"),Ua.forEach(a),pn=p(o),x(Io.$$.fragment,o),mn=p(o),Ne=n(o,"H2",{class:!0});var cl=l(Ne);Se=n(cl,"A",{id:!0,class:!0,href:!0});var Mf=l(Se);ps=n(Mf,"SPAN",{});var Bf=l(ps);x(zo.$$.fragment,Bf),Bf.forEach(a),Mf.forEach(a),vp=p(cl),ms=n(cl,"SPAN",{});var Rf=l(ms);_p=s(Rf,"Selecionando features para diferentes tarefas do modelo"),Rf.forEach(a),cl.forEach(a),cn=p(o),me=n(o,"P",{});var Wa=l(me);Ep=s(Wa,"Cada configura\xE7\xE3o pronta vem com um conjunto de "),cs=n(Wa,"EM",{});var Sf=l(cs);gp=s(Sf,"features"),Sf.forEach(a),xp=s(Wa,` que permitem exportar
modelos para diferentes tipos de tarefas. Conforme mostrado na tabela abaixo, cada recurso \xE9
associado a uma `),us=n(Wa,"CODE",{});var Ff=l(us);$p=s(Ff,"AutoClass"),Ff.forEach(a),Op=s(Wa," diferente:"),Wa.forEach(a),un=p(o),Fe=n(o,"TABLE",{});var ul=l(Fe);fs=n(ul,"THEAD",{});var Vf=l(fs);Xo=n(Vf,"TR",{});var fl=l(Xo);hs=n(fl,"TH",{});var Hf=l(hs);bp=s(Hf,"Feature"),Hf.forEach(a),qp=p(fl),vs=n(fl,"TH",{});var Gf=l(vs);Np=s(Gf,"Auto Class"),Gf.forEach(a),fl.forEach(a),Vf.forEach(a),jp=p(ul),M=n(ul,"TBODY",{});var G=l(M);Mo=n(G,"TR",{});var hl=l(Mo);Bo=n(hl,"TD",{});var vl=l(Bo);_s=n(vl,"CODE",{});var Uf=l(_s);kp=s(Uf,"causal-lm"),Uf.forEach(a),Tp=s(vl,", "),Es=n(vl,"CODE",{});var Wf=l(Es);wp=s(Wf,"causal-lm-with-past"),Wf.forEach(a),vl.forEach(a),Dp=p(hl),gs=n(hl,"TD",{});var Kf=l(gs);xs=n(Kf,"CODE",{});var Qf=l(xs);Cp=s(Qf,"AutoModelForCausalLM"),Qf.forEach(a),Kf.forEach(a),hl.forEach(a),Pp=p(G),Ro=n(G,"TR",{});var _l=l(Ro);So=n(_l,"TD",{});var El=l(So);$s=n(El,"CODE",{});var Jf=l($s);Lp=s(Jf,"default"),Jf.forEach(a),Ap=s(El,", "),Os=n(El,"CODE",{});var Yf=l(Os);yp=s(Yf,"default-with-past"),Yf.forEach(a),El.forEach(a),Ip=p(_l),bs=n(_l,"TD",{});var Zf=l(bs);qs=n(Zf,"CODE",{});var eh=l(qs);zp=s(eh,"AutoModel"),eh.forEach(a),Zf.forEach(a),_l.forEach(a),Xp=p(G),Fo=n(G,"TR",{});var gl=l(Fo);Ns=n(gl,"TD",{});var oh=l(Ns);js=n(oh,"CODE",{});var ah=l(js);Mp=s(ah,"masked-lm"),ah.forEach(a),oh.forEach(a),Bp=p(gl),ks=n(gl,"TD",{});var th=l(ks);Ts=n(th,"CODE",{});var sh=l(Ts);Rp=s(sh,"AutoModelForMaskedLM"),sh.forEach(a),th.forEach(a),gl.forEach(a),Sp=p(G),Vo=n(G,"TR",{});var xl=l(Vo);ws=n(xl,"TD",{});var rh=l(ws);Ds=n(rh,"CODE",{});var nh=l(Ds);Fp=s(nh,"question-answering"),nh.forEach(a),rh.forEach(a),Vp=p(xl),Cs=n(xl,"TD",{});var lh=l(Cs);Ps=n(lh,"CODE",{});var ih=l(Ps);Hp=s(ih,"AutoModelForQuestionAnswering"),ih.forEach(a),lh.forEach(a),xl.forEach(a),Gp=p(G),Ho=n(G,"TR",{});var $l=l(Ho);Go=n($l,"TD",{});var Ol=l(Go);Ls=n(Ol,"CODE",{});var dh=l(Ls);Up=s(dh,"seq2seq-lm"),dh.forEach(a),Wp=s(Ol,", "),As=n(Ol,"CODE",{});var ph=l(As);Kp=s(ph,"seq2seq-lm-with-past"),ph.forEach(a),Ol.forEach(a),Qp=p($l),ys=n($l,"TD",{});var mh=l(ys);Is=n(mh,"CODE",{});var ch=l(Is);Jp=s(ch,"AutoModelForSeq2SeqLM"),ch.forEach(a),mh.forEach(a),$l.forEach(a),Yp=p(G),Uo=n(G,"TR",{});var bl=l(Uo);zs=n(bl,"TD",{});var uh=l(zs);Xs=n(uh,"CODE",{});var fh=l(Xs);Zp=s(fh,"sequence-classification"),fh.forEach(a),uh.forEach(a),em=p(bl),Ms=n(bl,"TD",{});var hh=l(Ms);Bs=n(hh,"CODE",{});var vh=l(Bs);om=s(vh,"AutoModelForSequenceClassification"),vh.forEach(a),hh.forEach(a),bl.forEach(a),am=p(G),Wo=n(G,"TR",{});var ql=l(Wo);Rs=n(ql,"TD",{});var _h=l(Rs);Ss=n(_h,"CODE",{});var Eh=l(Ss);tm=s(Eh,"token-classification"),Eh.forEach(a),_h.forEach(a),sm=p(ql),Fs=n(ql,"TD",{});var gh=l(Fs);Vs=n(gh,"CODE",{});var xh=l(Vs);rm=s(xh,"AutoModelForTokenClassification"),xh.forEach(a),gh.forEach(a),ql.forEach(a),G.forEach(a),ul.forEach(a),fn=p(o),Ve=n(o,"P",{});var Nl=l(Ve);nm=s(Nl,`Para cada configura\xE7\xE3o, voc\xEA pode encontrar a lista de recursos suportados por meio do
`),Hs=n(Nl,"CODE",{});var $h=l(Hs);lm=s($h,"FeaturesManager"),$h.forEach(a),im=s(Nl,". Por exemplo, para DistilBERT temos:"),Nl.forEach(a),hn=p(o),x(Ko.$$.fragment,o),vn=p(o),ce=n(o,"P",{});var Ka=l(ce);dm=s(Ka,"Voc\xEA pode ent\xE3o passar um desses recursos para o argumento "),Gs=n(Ka,"CODE",{});var Oh=l(Gs);pm=s(Oh,"--feature"),Oh.forEach(a),mm=s(Ka,` no
pacote `),Us=n(Ka,"CODE",{});var bh=l(Us);cm=s(bh,"transformers.onnx"),bh.forEach(a),um=s(Ka,`. Por exemplo, para exportar um modelo de classifica\xE7\xE3o de texto, podemos
escolher um modelo ajustado no Hub e executar:`),Ka.forEach(a),_n=p(o),x(Qo.$$.fragment,o),En=p(o),Pa=n(o,"P",{});var qh=l(Pa);fm=s(qh,"Isso exibe os seguintes logs:"),qh.forEach(a),gn=p(o),x(Jo.$$.fragment,o),xn=p(o),Z=n(o,"P",{});var no=l(Z);hm=s(no,"Observe que, neste caso, os nomes de sa\xEDda do modelo ajustado s\xE3o "),Ws=n(no,"CODE",{});var Nh=l(Ws);vm=s(Nh,"logits"),Nh.forEach(a),_m=s(no,`
em vez do `),Ks=n(no,"CODE",{});var jh=l(Ks);Em=s(jh,"last_hidden_state"),jh.forEach(a),gm=s(no," que vimos com o checkpoint "),Qs=n(no,"CODE",{});var kh=l(Qs);xm=s(kh,"distilbert-base-uncased"),kh.forEach(a),$m=s(no,`
mais cedo. Isso \xE9 esperado, pois o modelo ajustado (fine-tuned) possui uma cabe\xE7a de classifica\xE7\xE3o de sequ\xEAncia.`),no.forEach(a),$n=p(o),x(He.$$.fragment,o),On=p(o),x(Ge.$$.fragment,o),bn=p(o),je=n(o,"H2",{class:!0});var jl=l(je);Ue=n(jl,"A",{id:!0,class:!0,href:!0});var Th=l(Ue);Js=n(Th,"SPAN",{});var wh=l(Js);x(Yo.$$.fragment,wh),wh.forEach(a),Th.forEach(a),Om=p(jl),Ys=n(jl,"SPAN",{});var Dh=l(Ys);bm=s(Dh,"Exportando um modelo para uma arquitetura sem suporte"),Dh.forEach(a),jl.forEach(a),qn=p(o),La=n(o,"P",{});var Ch=l(La);qm=s(Ch,`Se voc\xEA deseja exportar um modelo cuja arquitetura n\xE3o \xE9 suportada nativamente pela
biblioteca, h\xE1 tr\xEAs etapas principais a seguir:`),Ch.forEach(a),Nn=p(o),ue=n(o,"OL",{});var Qa=l(ue);Zs=n(Qa,"LI",{});var Ph=l(Zs);Nm=s(Ph,"Implemente uma configura\xE7\xE3o ONNX personalizada."),Ph.forEach(a),jm=p(Qa),er=n(Qa,"LI",{});var Lh=l(er);km=s(Lh,"Exporte o modelo para o ONNX."),Lh.forEach(a),Tm=p(Qa),or=n(Qa,"LI",{});var Ah=l(or);wm=s(Ah,"Valide as sa\xEDdas do PyTorch e dos modelos exportados."),Ah.forEach(a),Qa.forEach(a),jn=p(o),Aa=n(o,"P",{});var yh=l(Aa);Dm=s(yh,`Nesta se\xE7\xE3o, veremos como o DistilBERT foi implementado para mostrar o que est\xE1 envolvido
em cada passo.`),yh.forEach(a),kn=p(o),ke=n(o,"H3",{class:!0});var kl=l(ke);We=n(kl,"A",{id:!0,class:!0,href:!0});var Ih=l(We);ar=n(Ih,"SPAN",{});var zh=l(ar);x(Zo.$$.fragment,zh),zh.forEach(a),Ih.forEach(a),Cm=p(kl),tr=n(kl,"SPAN",{});var Xh=l(tr);Pm=s(Xh,"Implementando uma configura\xE7\xE3o ONNX personalizada"),Xh.forEach(a),kl.forEach(a),Tn=p(o),ya=n(o,"P",{});var Mh=l(ya);Lm=s(Mh,`Vamos come\xE7ar com o objeto de configura\xE7\xE3o ONNX. Fornecemos tr\xEAs classes abstratas que
voc\xEA deve herdar, dependendo do tipo de arquitetura de modelo que deseja exportar:`),Mh.forEach(a),wn=p(o),fe=n(o,"UL",{});var Ja=l(fe);Ia=n(Ja,"LI",{});var ou=l(Ia);Am=s(ou,"Modelos baseados em codificador herdam de "),sr=n(ou,"CODE",{});var Bh=l(sr);ym=s(Bh,"OnnxConfig"),Bh.forEach(a),ou.forEach(a),Im=p(Ja),za=n(Ja,"LI",{});var au=l(za);zm=s(au,"Modelos baseados em decodificador herdam de "),rr=n(au,"CODE",{});var Rh=l(rr);Xm=s(Rh,"OnnxConfigWithPast"),Rh.forEach(a),au.forEach(a),Mm=p(Ja),Xa=n(Ja,"LI",{});var tu=l(Xa);Bm=s(tu,"Os modelos codificador-decodificador herdam de "),nr=n(tu,"CODE",{});var Sh=l(nr);Rm=s(Sh,"OnnxSeq2SeqConfigWithPast"),Sh.forEach(a),tu.forEach(a),Ja.forEach(a),Dn=p(o),x(Ke.$$.fragment,o),Cn=p(o),Qe=n(o,"P",{});var Tl=l(Qe);Sm=s(Tl,`Como o DistilBERT \xE9 um modelo baseado em codificador, sua configura\xE7\xE3o \xE9 herdada de
`),lr=n(Tl,"CODE",{});var Fh=l(lr);Fm=s(Fh,"OnnxConfig"),Fh.forEach(a),Vm=s(Tl,":"),Tl.forEach(a),Pn=p(o),x(ea.$$.fragment,o),Ln=p(o),V=n(o,"P",{});var Ee=l(V);Hm=s(Ee,"Todo objeto de configura\xE7\xE3o deve implementar a propriedade "),ir=n(Ee,"CODE",{});var Vh=l(ir);Gm=s(Vh,"inputs"),Vh.forEach(a),Um=s(Ee,` e retornar um mapeamento,
onde cada chave corresponde a uma entrada esperada e cada valor indica o eixo
dessa entrada. Para o DistilBERT, podemos ver que duas entradas s\xE3o necess\xE1rias: `),dr=n(Ee,"CODE",{});var Hh=l(dr);Wm=s(Hh,"input_ids"),Hh.forEach(a),Km=s(Ee,` e
`),pr=n(Ee,"CODE",{});var Gh=l(pr);Qm=s(Gh,"attention_mask"),Gh.forEach(a),Jm=s(Ee,". Essas entradas t\xEAm a mesma forma de "),mr=n(Ee,"CODE",{});var Uh=l(mr);Ym=s(Uh,"(batch_size, sequence_length)"),Uh.forEach(a),Zm=s(Ee,`
\xE9 por isso que vemos os mesmos eixos usados na configura\xE7\xE3o.`),Ee.forEach(a),An=p(o),x(Je.$$.fragment,o),yn=p(o),Ma=n(o,"P",{});var Wh=l(Ma);ec=s(Wh,`Depois de implementar uma configura\xE7\xE3o ONNX, voc\xEA pode instanci\xE1-la fornecendo a
configura\xE7\xE3o do modelo base da seguinte forma:`),Wh.forEach(a),In=p(o),x(oa.$$.fragment,o),zn=p(o),Ba=n(o,"P",{});var Kh=l(Ba);oc=s(Kh,`O objeto resultante tem v\xE1rias propriedades \xFAteis. Por exemplo, voc\xEA pode visualizar o conjunto de operadores ONNX
que ser\xE1 usado durante a exporta\xE7\xE3o:`),Kh.forEach(a),Xn=p(o),x(aa.$$.fragment,o),Mn=p(o),Ra=n(o,"P",{});var Qh=l(Ra);ac=s(Qh,"Voc\xEA tamb\xE9m pode visualizar as sa\xEDdas associadas ao modelo da seguinte forma:"),Qh.forEach(a),Bn=p(o),x(ta.$$.fragment,o),Rn=p(o),H=n(o,"P",{});var ge=l(H);tc=s(ge,`Observe que a propriedade outputs segue a mesma estrutura das entradas; ele retorna um
`),cr=n(ge,"CODE",{});var Jh=l(cr);sc=s(Jh,"OrderedDict"),Jh.forEach(a),rc=s(ge,` de sa\xEDdas nomeadas e suas formas. A estrutura de sa\xEDda est\xE1 ligada a
escolha do recurso com o qual a configura\xE7\xE3o \xE9 inicializada. Por padr\xE3o, a configura\xE7\xE3o do ONNX
\xE9 inicializada com o recurso `),ur=n(ge,"CODE",{});var Yh=l(ur);nc=s(Yh,"default"),Yh.forEach(a),lc=s(ge,` que corresponde \xE0 exporta\xE7\xE3o de um
modelo carregado com a classe `),fr=n(ge,"CODE",{});var Zh=l(fr);ic=s(Zh,"AutoModel"),Zh.forEach(a),dc=s(ge,`. Se voc\xEA deseja exportar um modelo para outra tarefa,
apenas forne\xE7a um recurso diferente para o argumento `),hr=n(ge,"CODE",{});var ev=l(hr);pc=s(ev,"task"),ev.forEach(a),mc=s(ge,` quando voc\xEA inicializar a configura\xE7\xE3o ONNX
. Por exemplo, se quisermos exportar o DistilBERT com uma sequ\xEAncia
de classifica\xE7\xE3o, poder\xEDamos usar:`),ge.forEach(a),Sn=p(o),x(sa.$$.fragment,o),Fn=p(o),x(Ye.$$.fragment,o),Vn=p(o),Te=n(o,"H3",{class:!0});var wl=l(Te);Ze=n(wl,"A",{id:!0,class:!0,href:!0});var ov=l(Ze);vr=n(ov,"SPAN",{});var av=l(vr);x(ra.$$.fragment,av),av.forEach(a),ov.forEach(a),cc=p(wl),_r=n(wl,"SPAN",{});var tv=l(_r);uc=s(tv,"Exportando um modelo"),tv.forEach(a),wl.forEach(a),Hn=p(o),he=n(o,"P",{});var Ya=l(he);fc=s(Ya,`Depois de ter implementado a configura\xE7\xE3o do ONNX, o pr\xF3ximo passo \xE9 exportar o modelo.
Aqui podemos usar a fun\xE7\xE3o `),Er=n(Ya,"CODE",{});var sv=l(Er);hc=s(sv,"export()"),sv.forEach(a),vc=s(Ya," fornecida pelo pacote "),gr=n(Ya,"CODE",{});var rv=l(gr);_c=s(rv,"transformers.onnx"),rv.forEach(a),Ec=s(Ya,`.
Esta fun\xE7\xE3o espera a configura\xE7\xE3o do ONNX, juntamente com o modelo base e o tokenizer,
e o caminho para salvar o arquivo exportado:`),Ya.forEach(a),Gn=p(o),x(na.$$.fragment,o),Un=p(o),R=n(o,"P",{});var ee=l(R);gc=s(ee,"Os "),xr=n(ee,"CODE",{});var nv=l(xr);xc=s(nv,"onnx_inputs"),nv.forEach(a),$c=s(ee," e "),$r=n(ee,"CODE",{});var lv=l($r);Oc=s(lv,"onnx_outputs"),lv.forEach(a),bc=s(ee," retornados pela fun\xE7\xE3o "),Or=n(ee,"CODE",{});var iv=l(Or);qc=s(iv,"export()"),iv.forEach(a),Nc=s(ee,` s\xE3o listas de
chaves definidas nas propriedades `),br=n(ee,"CODE",{});var dv=l(br);jc=s(dv,"inputs"),dv.forEach(a),kc=s(ee," e "),qr=n(ee,"CODE",{});var pv=l(qr);Tc=s(pv,"outputs"),pv.forEach(a),wc=s(ee,` da configura\xE7\xE3o. Uma vez que o
modelo \xE9 exportado, voc\xEA pode testar se o modelo est\xE1 bem formado da seguinte forma:`),ee.forEach(a),Wn=p(o),x(la.$$.fragment,o),Kn=p(o),x(eo.$$.fragment,o),Qn=p(o),we=n(o,"H3",{class:!0});var Dl=l(we);oo=n(Dl,"A",{id:!0,class:!0,href:!0});var mv=l(oo);Nr=n(mv,"SPAN",{});var cv=l(Nr);x(ia.$$.fragment,cv),cv.forEach(a),mv.forEach(a),Dc=p(Dl),jr=n(Dl,"SPAN",{});var uv=l(jr);Cc=s(uv,"Validando a sa\xEDda dos modelos"),uv.forEach(a),Dl.forEach(a),Jn=p(o),ve=n(o,"P",{});var Za=l(ve);Pc=s(Za,`A etapa final \xE9 validar se as sa\xEDdas do modelo base e exportado concordam
dentro de alguma toler\xE2ncia absoluta. Aqui podemos usar a fun\xE7\xE3o `),kr=n(Za,"CODE",{});var fv=l(kr);Lc=s(fv,"validate_model_outputs()"),fv.forEach(a),Ac=s(Za,`
fornecida pelo pacote `),Tr=n(Za,"CODE",{});var hv=l(Tr);yc=s(hv,"transformers.onnx"),hv.forEach(a),Ic=s(Za," da seguinte forma:"),Za.forEach(a),Yn=p(o),x(da.$$.fragment,o),Zn=p(o),ao=n(o,"P",{});var Cl=l(ao);zc=s(Cl,"Esta fun\xE7\xE3o usa o m\xE9todo "),wr=n(Cl,"CODE",{});var vv=l(wr);Xc=s(vv,"generate_dummy_inputs()"),vv.forEach(a),Mc=s(Cl,` para
gerar entradas para o modelo base e o exportado, e a toler\xE2ncia absoluta pode ser
definida na configura\xE7\xE3o. Geralmente encontramos concord\xE2ncia num\xE9rica em 1e-6 a 1e-4
de alcance, embora qualquer coisa menor que 1e-3 provavelmente esteja OK.`),Cl.forEach(a),el=p(o),De=n(o,"H2",{class:!0});var Pl=l(De);to=n(Pl,"A",{id:!0,class:!0,href:!0});var _v=l(to);Dr=n(_v,"SPAN",{});var Ev=l(Dr);x(pa.$$.fragment,Ev),Ev.forEach(a),_v.forEach(a),Bc=p(Pl),Cr=n(Pl,"SPAN",{});var gv=l(Cr);Rc=s(gv,"Contribuindo com uma nova configura\xE7\xE3o para \u{1F917} Transformers"),gv.forEach(a),Pl.forEach(a),ol=p(o),Sa=n(o,"P",{});var xv=l(Sa);Sc=s(xv,`Estamos procurando expandir o conjunto de configura\xE7\xF5es prontas e receber contribui\xE7\xF5es
da comunidade! Se voc\xEA gostaria de contribuir para a biblioteca, voc\xEA
precisar\xE1:`),xv.forEach(a),al=p(o),_e=n(o,"UL",{});var et=l(_e);ma=n(et,"LI",{});var Ll=l(ma);Fc=s(Ll,"Implemente a configura\xE7\xE3o do ONNX no arquivo "),Pr=n(Ll,"CODE",{});var $v=l(Pr);Vc=s($v,"configuration_<model_name>.py"),$v.forEach(a),Hc=s(Ll,` correspondente
Arquivo`),Ll.forEach(a),Gc=p(et),Fa=n(et,"LI",{});var su=l(Fa);Uc=s(su,`Incluir a arquitetura do modelo e recursos correspondentes em
`),Lr=n(su,"CODE",{});var Ov=l(Lr);Wc=s(Ov,"~onnx.features.FeatureManager"),Ov.forEach(a),su.forEach(a),Kc=p(et),Va=n(et,"LI",{});var ru=l(Va);Qc=s(ru,"Adicione sua arquitetura de modelo aos testes em "),Ar=n(ru,"CODE",{});var bv=l(Ar);Jc=s(bv,"test_onnx_v2.py"),bv.forEach(a),ru.forEach(a),et.forEach(a),tl=p(o),so=n(o,"P",{});var Al=l(so);Yc=s(Al,"Confira como ficou a configura\xE7\xE3o do "),ca=n(Al,"A",{href:!0,rel:!0});var qv=l(ca);Zc=s(qv,"IBERT"),qv.forEach(a),eu=s(Al,` para obter uma
id\xE9ia do que est\xE1 envolvido.`),Al.forEach(a),this.h()},h(){_(f,"name","hf:doc:metadata"),_(f,"content",JSON.stringify(Xv)),_(N,"id","exportando-modelos-para-onnx"),_(N,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),_(N,"href","#exportando-modelos-para-onnx"),_(h,"class","relative group"),_(w,"href","http://onnx.ai"),_(w,"rel","nofollow"),_(J,"href","main_classes/onnx"),_(Xe,"id","exportando-um-modelo-para-onnx"),_(Xe,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),_(Xe,"href","#exportando-um-modelo-para-onnx"),_(qe,"class","relative group"),_(ko,"href","https://onnx.ai/supported-tools.html#deployModel"),_(ko,"rel","nofollow"),_(To,"href","https://onnxruntime.ai/"),_(To,"rel","nofollow"),_(Co,"href","https://huggingface.co/keras-io"),_(Co,"rel","nofollow"),_(Se,"id","selecionando-features-para-diferentes-tarefas-do-modelo"),_(Se,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),_(Se,"href","#selecionando-features-para-diferentes-tarefas-do-modelo"),_(Ne,"class","relative group"),_(Ue,"id","exportando-um-modelo-para-uma-arquitetura-sem-suporte"),_(Ue,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),_(Ue,"href","#exportando-um-modelo-para-uma-arquitetura-sem-suporte"),_(je,"class","relative group"),_(We,"id","implementando-uma-configurao-onnx-personalizada"),_(We,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),_(We,"href","#implementando-uma-configurao-onnx-personalizada"),_(ke,"class","relative group"),_(Ze,"id","exportando-um-modelo"),_(Ze,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),_(Ze,"href","#exportando-um-modelo"),_(Te,"class","relative group"),_(oo,"id","validando-a-sada-dos-modelos"),_(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"),_(oo,"href","#validando-a-sada-dos-modelos"),_(we,"class","relative group"),_(to,"id","contribuindo-com-uma-nova-configurao-para-transformers"),_(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"),_(to,"href","#contribuindo-com-uma-nova-configurao-para-transformers"),_(De,"class","relative group"),_(ca,"href","https://github.com/huggingface/transformers/pull/14868/files"),_(ca,"rel","nofollow")},m(o,i){e(document.head,f),m(o,D,i),m(o,h,i),e(h,N),e(N,T),$(v,T,null),e(h,E),e(h,C),e(C,j),m(o,k,i),m(o,A,i),e(A,P),e(A,w),e(w,U),e(A,S),m(o,F,i),$(W,o,i),m(o,re,i),m(o,K,i),e(K,io),e(K,oe),e(oe,po),e(K,mo),m(o,xe,i),m(o,L,i),e(L,co),m(o,ne,i),m(o,Q,i),e(Q,uo),e(Q,J),e(J,$e),e($e,fo),e(Q,Oe),m(o,Ce,i),m(o,le,i),e(le,be),m(o,Pe,i),m(o,c,i),e(c,ae),e(ae,ho),e(c,vo),e(c,te),e(te,_o),e(c,Eo),e(c,se),e(se,go),e(c,xo),e(c,X),e(X,y),e(c,_a),e(c,Le),e(Le,Ea),e(c,ga),e(c,Ae),e(Ae,xa),e(c,$a),e(c,I),e(I,Oa),e(c,ba),e(c,ye),e(ye,qa),e(c,Na),e(c,Ie),e(Ie,ja),e(c,yl),e(c,ot),e(ot,Il),e(c,zl),e(c,at),e(at,Xl),e(c,Ml),e(c,tt),e(tt,Bl),e(c,Rl),e(c,st),e(st,Sl),e(c,Fl),e(c,rt),e(rt,Vl),e(c,Hl),e(c,nt),e(nt,Gl),e(c,Ul),e(c,lt),e(lt,Wl),e(c,Kl),e(c,it),e(it,Ql),e(c,Jl),e(c,dt),e(dt,Yl),e(c,Zl),e(c,pt),e(pt,ei),e(c,oi),e(c,mt),e(mt,ai),e(c,ti),e(c,ct),e(ct,si),e(c,ri),e(c,ut),e(ut,ni),e(c,li),e(c,ft),e(ft,ii),e(c,di),e(c,ht),e(ht,pi),e(c,mi),e(c,vt),e(vt,ci),e(c,ui),e(c,_t),e(_t,fi),e(c,hi),e(c,Et),e(Et,vi),e(c,_i),e(c,gt),e(gt,Ei),e(c,gi),e(c,xt),e(xt,xi),e(c,$i),e(c,$t),e($t,Oi),e(c,bi),e(c,Ot),e(Ot,qi),e(c,Ni),e(c,bt),e(bt,ji),e(c,ki),e(c,qt),e(qt,Ti),e(c,wi),e(c,Nt),e(Nt,Di),e(c,Ci),e(c,jt),e(jt,Pi),e(c,Li),e(c,kt),e(kt,Ai),e(c,yi),e(c,Tt),e(Tt,Ii),e(c,zi),e(c,wt),e(wt,Xi),e(c,Mi),e(c,Dt),e(Dt,Bi),e(c,Ri),e(c,Ct),e(Ct,Si),e(c,Fi),e(c,Pt),e(Pt,Vi),e(c,Hi),e(c,Lt),e(Lt,Gi),e(c,Ui),e(c,At),e(At,Wi),e(c,Ki),e(c,yt),e(yt,Qi),e(c,Ji),e(c,It),e(It,Yi),e(c,Zi),e(c,zt),e(zt,ed),e(c,od),e(c,Xt),e(Xt,ad),e(c,td),e(c,Mt),e(Mt,sd),e(c,rd),e(c,Bt),e(Bt,nd),e(c,ld),e(c,Rt),e(Rt,id),e(c,dd),e(c,St),e(St,pd),e(c,md),e(c,Ft),e(Ft,cd),e(c,ud),e(c,Vt),e(Vt,fd),e(c,hd),e(c,Ht),e(Ht,vd),e(c,_d),e(c,Gt),e(Gt,Ed),e(c,gd),e(c,Ut),e(Ut,xd),e(c,$d),e(c,Wt),e(Wt,Od),e(c,bd),e(c,Kt),e(Kt,qd),e(c,Nd),e(c,Qt),e(Qt,jd),m(o,Mr,i),m(o,ka,i),e(ka,kd),m(o,Br,i),m(o,ze,i),e(ze,$o),e($o,Td),e($o,Jt),e(Jt,wd),e($o,Dd),e(ze,Cd),e(ze,Yt),e(Yt,Pd),m(o,Rr,i),m(o,qe,i),e(qe,Xe),e(Xe,Zt),$(Oo,Zt,null),e(qe,Ld),e(qe,es),e(es,Ad),m(o,Sr,i),m(o,Ta,i),e(Ta,yd),m(o,Fr,i),$(bo,o,i),m(o,Vr,i),m(o,Me,i),e(Me,Id),e(Me,os),e(os,zd),e(Me,Xd),m(o,Hr,i),$(qo,o,i),m(o,Gr,i),m(o,wa,i),e(wa,Md),m(o,Ur,i),$(No,o,i),m(o,Wr,i),m(o,Da,i),e(Da,Bd),m(o,Kr,i),$(jo,o,i),m(o,Qr,i),m(o,ie,i),e(ie,Rd),e(ie,as),e(as,Sd),e(ie,Fd),e(ie,ts),e(ts,Vd),e(ie,Hd),m(o,Jr,i),m(o,Y,i),e(Y,Gd),e(Y,ss),e(ss,Ud),e(Y,Wd),e(Y,ko),e(ko,Kd),e(Y,Qd),e(Y,To),e(To,Jd),e(Y,Yd),m(o,Yr,i),$(wo,o,i),m(o,Zr,i),m(o,Be,i),e(Be,Zd),e(Be,rs),e(rs,ep),e(Be,op),m(o,en,i),$(Do,o,i),m(o,on,i),m(o,Re,i),e(Re,ap),e(Re,Co),e(Co,tp),e(Re,sp),m(o,an,i),$(Po,o,i),m(o,tn,i),m(o,Ca,i),e(Ca,rp),m(o,sn,i),$(Lo,o,i),m(o,rn,i),m(o,de,i),e(de,np),e(de,ns),e(ns,lp),e(de,ip),e(de,ls),e(ls,dp),e(de,pp),m(o,nn,i),$(Ao,o,i),m(o,ln,i),$(yo,o,i),m(o,dn,i),m(o,pe,i),e(pe,mp),e(pe,is),e(is,cp),e(pe,up),e(pe,ds),e(ds,fp),e(pe,hp),m(o,pn,i),$(Io,o,i),m(o,mn,i),m(o,Ne,i),e(Ne,Se),e(Se,ps),$(zo,ps,null),e(Ne,vp),e(Ne,ms),e(ms,_p),m(o,cn,i),m(o,me,i),e(me,Ep),e(me,cs),e(cs,gp),e(me,xp),e(me,us),e(us,$p),e(me,Op),m(o,un,i),m(o,Fe,i),e(Fe,fs),e(fs,Xo),e(Xo,hs),e(hs,bp),e(Xo,qp),e(Xo,vs),e(vs,Np),e(Fe,jp),e(Fe,M),e(M,Mo),e(Mo,Bo),e(Bo,_s),e(_s,kp),e(Bo,Tp),e(Bo,Es),e(Es,wp),e(Mo,Dp),e(Mo,gs),e(gs,xs),e(xs,Cp),e(M,Pp),e(M,Ro),e(Ro,So),e(So,$s),e($s,Lp),e(So,Ap),e(So,Os),e(Os,yp),e(Ro,Ip),e(Ro,bs),e(bs,qs),e(qs,zp),e(M,Xp),e(M,Fo),e(Fo,Ns),e(Ns,js),e(js,Mp),e(Fo,Bp),e(Fo,ks),e(ks,Ts),e(Ts,Rp),e(M,Sp),e(M,Vo),e(Vo,ws),e(ws,Ds),e(Ds,Fp),e(Vo,Vp),e(Vo,Cs),e(Cs,Ps),e(Ps,Hp),e(M,Gp),e(M,Ho),e(Ho,Go),e(Go,Ls),e(Ls,Up),e(Go,Wp),e(Go,As),e(As,Kp),e(Ho,Qp),e(Ho,ys),e(ys,Is),e(Is,Jp),e(M,Yp),e(M,Uo),e(Uo,zs),e(zs,Xs),e(Xs,Zp),e(Uo,em),e(Uo,Ms),e(Ms,Bs),e(Bs,om),e(M,am),e(M,Wo),e(Wo,Rs),e(Rs,Ss),e(Ss,tm),e(Wo,sm),e(Wo,Fs),e(Fs,Vs),e(Vs,rm),m(o,fn,i),m(o,Ve,i),e(Ve,nm),e(Ve,Hs),e(Hs,lm),e(Ve,im),m(o,hn,i),$(Ko,o,i),m(o,vn,i),m(o,ce,i),e(ce,dm),e(ce,Gs),e(Gs,pm),e(ce,mm),e(ce,Us),e(Us,cm),e(ce,um),m(o,_n,i),$(Qo,o,i),m(o,En,i),m(o,Pa,i),e(Pa,fm),m(o,gn,i),$(Jo,o,i),m(o,xn,i),m(o,Z,i),e(Z,hm),e(Z,Ws),e(Ws,vm),e(Z,_m),e(Z,Ks),e(Ks,Em),e(Z,gm),e(Z,Qs),e(Qs,xm),e(Z,$m),m(o,$n,i),$(He,o,i),m(o,On,i),$(Ge,o,i),m(o,bn,i),m(o,je,i),e(je,Ue),e(Ue,Js),$(Yo,Js,null),e(je,Om),e(je,Ys),e(Ys,bm),m(o,qn,i),m(o,La,i),e(La,qm),m(o,Nn,i),m(o,ue,i),e(ue,Zs),e(Zs,Nm),e(ue,jm),e(ue,er),e(er,km),e(ue,Tm),e(ue,or),e(or,wm),m(o,jn,i),m(o,Aa,i),e(Aa,Dm),m(o,kn,i),m(o,ke,i),e(ke,We),e(We,ar),$(Zo,ar,null),e(ke,Cm),e(ke,tr),e(tr,Pm),m(o,Tn,i),m(o,ya,i),e(ya,Lm),m(o,wn,i),m(o,fe,i),e(fe,Ia),e(Ia,Am),e(Ia,sr),e(sr,ym),e(fe,Im),e(fe,za),e(za,zm),e(za,rr),e(rr,Xm),e(fe,Mm),e(fe,Xa),e(Xa,Bm),e(Xa,nr),e(nr,Rm),m(o,Dn,i),$(Ke,o,i),m(o,Cn,i),m(o,Qe,i),e(Qe,Sm),e(Qe,lr),e(lr,Fm),e(Qe,Vm),m(o,Pn,i),$(ea,o,i),m(o,Ln,i),m(o,V,i),e(V,Hm),e(V,ir),e(ir,Gm),e(V,Um),e(V,dr),e(dr,Wm),e(V,Km),e(V,pr),e(pr,Qm),e(V,Jm),e(V,mr),e(mr,Ym),e(V,Zm),m(o,An,i),$(Je,o,i),m(o,yn,i),m(o,Ma,i),e(Ma,ec),m(o,In,i),$(oa,o,i),m(o,zn,i),m(o,Ba,i),e(Ba,oc),m(o,Xn,i),$(aa,o,i),m(o,Mn,i),m(o,Ra,i),e(Ra,ac),m(o,Bn,i),$(ta,o,i),m(o,Rn,i),m(o,H,i),e(H,tc),e(H,cr),e(cr,sc),e(H,rc),e(H,ur),e(ur,nc),e(H,lc),e(H,fr),e(fr,ic),e(H,dc),e(H,hr),e(hr,pc),e(H,mc),m(o,Sn,i),$(sa,o,i),m(o,Fn,i),$(Ye,o,i),m(o,Vn,i),m(o,Te,i),e(Te,Ze),e(Ze,vr),$(ra,vr,null),e(Te,cc),e(Te,_r),e(_r,uc),m(o,Hn,i),m(o,he,i),e(he,fc),e(he,Er),e(Er,hc),e(he,vc),e(he,gr),e(gr,_c),e(he,Ec),m(o,Gn,i),$(na,o,i),m(o,Un,i),m(o,R,i),e(R,gc),e(R,xr),e(xr,xc),e(R,$c),e(R,$r),e($r,Oc),e(R,bc),e(R,Or),e(Or,qc),e(R,Nc),e(R,br),e(br,jc),e(R,kc),e(R,qr),e(qr,Tc),e(R,wc),m(o,Wn,i),$(la,o,i),m(o,Kn,i),$(eo,o,i),m(o,Qn,i),m(o,we,i),e(we,oo),e(oo,Nr),$(ia,Nr,null),e(we,Dc),e(we,jr),e(jr,Cc),m(o,Jn,i),m(o,ve,i),e(ve,Pc),e(ve,kr),e(kr,Lc),e(ve,Ac),e(ve,Tr),e(Tr,yc),e(ve,Ic),m(o,Yn,i),$(da,o,i),m(o,Zn,i),m(o,ao,i),e(ao,zc),e(ao,wr),e(wr,Xc),e(ao,Mc),m(o,el,i),m(o,De,i),e(De,to),e(to,Dr),$(pa,Dr,null),e(De,Bc),e(De,Cr),e(Cr,Rc),m(o,ol,i),m(o,Sa,i),e(Sa,Sc),m(o,al,i),m(o,_e,i),e(_e,ma),e(ma,Fc),e(ma,Pr),e(Pr,Vc),e(ma,Hc),e(_e,Gc),e(_e,Fa),e(Fa,Uc),e(Fa,Lr),e(Lr,Wc),e(_e,Kc),e(_e,Va),e(Va,Qc),e(Va,Ar),e(Ar,Jc),m(o,tl,i),m(o,so,i),e(so,Yc),e(so,ca),e(ca,Zc),e(so,eu),sl=!0},p(o,[i]){const ua={};i&2&&(ua.$$scope={dirty:i,ctx:o}),W.$set(ua);const yr={};i&2&&(yr.$$scope={dirty:i,ctx:o}),He.$set(yr);const Ir={};i&2&&(Ir.$$scope={dirty:i,ctx:o}),Ge.$set(Ir);const zr={};i&2&&(zr.$$scope={dirty:i,ctx:o}),Ke.$set(zr);const fa={};i&2&&(fa.$$scope={dirty:i,ctx:o}),Je.$set(fa);const Xr={};i&2&&(Xr.$$scope={dirty:i,ctx:o}),Ye.$set(Xr);const ha={};i&2&&(ha.$$scope={dirty:i,ctx:o}),eo.$set(ha)},i(o){sl||(O(v.$$.fragment,o),O(W.$$.fragment,o),O(Oo.$$.fragment,o),O(bo.$$.fragment,o),O(qo.$$.fragment,o),O(No.$$.fragment,o),O(jo.$$.fragment,o),O(wo.$$.fragment,o),O(Do.$$.fragment,o),O(Po.$$.fragment,o),O(Lo.$$.fragment,o),O(Ao.$$.fragment,o),O(yo.$$.fragment,o),O(Io.$$.fragment,o),O(zo.$$.fragment,o),O(Ko.$$.fragment,o),O(Qo.$$.fragment,o),O(Jo.$$.fragment,o),O(He.$$.fragment,o),O(Ge.$$.fragment,o),O(Yo.$$.fragment,o),O(Zo.$$.fragment,o),O(Ke.$$.fragment,o),O(ea.$$.fragment,o),O(Je.$$.fragment,o),O(oa.$$.fragment,o),O(aa.$$.fragment,o),O(ta.$$.fragment,o),O(sa.$$.fragment,o),O(Ye.$$.fragment,o),O(ra.$$.fragment,o),O(na.$$.fragment,o),O(la.$$.fragment,o),O(eo.$$.fragment,o),O(ia.$$.fragment,o),O(da.$$.fragment,o),O(pa.$$.fragment,o),sl=!0)},o(o){b(v.$$.fragment,o),b(W.$$.fragment,o),b(Oo.$$.fragment,o),b(bo.$$.fragment,o),b(qo.$$.fragment,o),b(No.$$.fragment,o),b(jo.$$.fragment,o),b(wo.$$.fragment,o),b(Do.$$.fragment,o),b(Po.$$.fragment,o),b(Lo.$$.fragment,o),b(Ao.$$.fragment,o),b(yo.$$.fragment,o),b(Io.$$.fragment,o),b(zo.$$.fragment,o),b(Ko.$$.fragment,o),b(Qo.$$.fragment,o),b(Jo.$$.fragment,o),b(He.$$.fragment,o),b(Ge.$$.fragment,o),b(Yo.$$.fragment,o),b(Zo.$$.fragment,o),b(Ke.$$.fragment,o),b(ea.$$.fragment,o),b(Je.$$.fragment,o),b(oa.$$.fragment,o),b(aa.$$.fragment,o),b(ta.$$.fragment,o),b(sa.$$.fragment,o),b(Ye.$$.fragment,o),b(ra.$$.fragment,o),b(na.$$.fragment,o),b(la.$$.fragment,o),b(eo.$$.fragment,o),b(ia.$$.fragment,o),b(da.$$.fragment,o),b(pa.$$.fragment,o),sl=!1},d(o){a(f),o&&a(D),o&&a(h),q(v),o&&a(k),o&&a(A),o&&a(F),q(W,o),o&&a(re),o&&a(K),o&&a(xe),o&&a(L),o&&a(ne),o&&a(Q),o&&a(Ce),o&&a(le),o&&a(Pe),o&&a(c),o&&a(Mr),o&&a(ka),o&&a(Br),o&&a(ze),o&&a(Rr),o&&a(qe),q(Oo),o&&a(Sr),o&&a(Ta),o&&a(Fr),q(bo,o),o&&a(Vr),o&&a(Me),o&&a(Hr),q(qo,o),o&&a(Gr),o&&a(wa),o&&a(Ur),q(No,o),o&&a(Wr),o&&a(Da),o&&a(Kr),q(jo,o),o&&a(Qr),o&&a(ie),o&&a(Jr),o&&a(Y),o&&a(Yr),q(wo,o),o&&a(Zr),o&&a(Be),o&&a(en),q(Do,o),o&&a(on),o&&a(Re),o&&a(an),q(Po,o),o&&a(tn),o&&a(Ca),o&&a(sn),q(Lo,o),o&&a(rn),o&&a(de),o&&a(nn),q(Ao,o),o&&a(ln),q(yo,o),o&&a(dn),o&&a(pe),o&&a(pn),q(Io,o),o&&a(mn),o&&a(Ne),q(zo),o&&a(cn),o&&a(me),o&&a(un),o&&a(Fe),o&&a(fn),o&&a(Ve),o&&a(hn),q(Ko,o),o&&a(vn),o&&a(ce),o&&a(_n),q(Qo,o),o&&a(En),o&&a(Pa),o&&a(gn),q(Jo,o),o&&a(xn),o&&a(Z),o&&a($n),q(He,o),o&&a(On),q(Ge,o),o&&a(bn),o&&a(je),q(Yo),o&&a(qn),o&&a(La),o&&a(Nn),o&&a(ue),o&&a(jn),o&&a(Aa),o&&a(kn),o&&a(ke),q(Zo),o&&a(Tn),o&&a(ya),o&&a(wn),o&&a(fe),o&&a(Dn),q(Ke,o),o&&a(Cn),o&&a(Qe),o&&a(Pn),q(ea,o),o&&a(Ln),o&&a(V),o&&a(An),q(Je,o),o&&a(yn),o&&a(Ma),o&&a(In),q(oa,o),o&&a(zn),o&&a(Ba),o&&a(Xn),q(aa,o),o&&a(Mn),o&&a(Ra),o&&a(Bn),q(ta,o),o&&a(Rn),o&&a(H),o&&a(Sn),q(sa,o),o&&a(Fn),q(Ye,o),o&&a(Vn),o&&a(Te),q(ra),o&&a(Hn),o&&a(he),o&&a(Gn),q(na,o),o&&a(Un),o&&a(R),o&&a(Wn),q(la,o),o&&a(Kn),q(eo,o),o&&a(Qn),o&&a(we),q(ia),o&&a(Jn),o&&a(ve),o&&a(Yn),q(da,o),o&&a(Zn),o&&a(ao),o&&a(el),o&&a(De),q(pa),o&&a(ol),o&&a(Sa),o&&a(al),o&&a(_e),o&&a(tl),o&&a(so)}}}const Xv={local:"exportando-modelos-para-onnx",sections:[{local:"exportando-um-modelo-para-onnx",title:"Exportando um modelo para ONNX"},{local:"selecionando-features-para-diferentes-tarefas-do-modelo",title:"Selecionando features para diferentes tarefas do modelo"},{local:"exportando-um-modelo-para-uma-arquitetura-sem-suporte",sections:[{local:"implementando-uma-configurao-onnx-personalizada",title:"Implementando uma configura\xE7\xE3o ONNX personalizada"},{local:"exportando-um-modelo",title:"Exportando um modelo"},{local:"validando-a-sada-dos-modelos",title:"Validando a sa\xEDda dos modelos"}],title:"Exportando um modelo para uma arquitetura sem suporte"},{local:"contribuindo-com-uma-nova-configurao-para-transformers",title:"Contribuindo com uma nova configura\xE7\xE3o para \u{1F917} Transformers"}],title:"Exportando modelos para ONNX "};function Mv(B){return wv(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class Vv extends Nv{constructor(f){super();jv(this,f,Mv,zv,kv,{})}}export{Vv as default,Xv as metadata};
