import{S as qb,i as wb,s as kb,e as r,k as c,w as g,t,M as Tb,c as n,d as o,m as p,a as l,x as E,h as s,b as u,G as a,g as d,y as $,q as b,o as x,B as y,v as Ob,L as yb}from"../chunks/vendor-hf-doc-builder.js";import{T as ls}from"../chunks/Tip-hf-doc-builder.js";import{I}from"../chunks/IconCopyLink-hf-doc-builder.js";import{C as z}from"../chunks/CodeBlock-hf-doc-builder.js";import{F as Nb,M as jb}from"../chunks/Markdown-hf-doc-builder.js";import"../chunks/IconTensorflow-hf-doc-builder.js";function Pb(M){let m,q,_,j,k,w,A,N,P,C,S,O,D;return m=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>)`}}),O=new z({props:{code:"python -m transformers.onnx --model=local-pt-checkpoint onnx/",highlighted:"python -m transformers.onnx --model=local-pt-checkpoint onnx/"}}),{c(){g(m.$$.fragment),q=c(),_=r("p"),j=t("Una vez que se guarda el checkpoint, podemos exportarlo a ONNX usando el argumento "),k=r("code"),w=t("--model"),A=t(`
del paquete `),N=r("code"),P=t("transformers.onnx"),C=t(" al directorio deseado:"),S=c(),g(O.$$.fragment)},l(v){E(m.$$.fragment,v),q=p(v),_=n(v,"P",{});var T=l(_);j=s(T,"Una vez que se guarda el checkpoint, podemos exportarlo a ONNX usando el argumento "),k=n(T,"CODE",{});var B=l(k);w=s(B,"--model"),B.forEach(o),A=s(T,`
del paquete `),N=n(T,"CODE",{});var G=l(N);P=s(G,"transformers.onnx"),G.forEach(o),C=s(T," al directorio deseado:"),T.forEach(o),S=p(v),E(O.$$.fragment,v)},m(v,T){$(m,v,T),d(v,q,T),d(v,_,T),a(_,j),a(_,k),a(k,w),a(_,A),a(_,N),a(N,P),a(_,C),d(v,S,T),$(O,v,T),D=!0},p:yb,i(v){D||(b(m.$$.fragment,v),b(O.$$.fragment,v),D=!0)},o(v){x(m.$$.fragment,v),x(O.$$.fragment,v),D=!1},d(v){y(m,v),v&&o(q),v&&o(_),v&&o(S),y(O,v)}}}function Ab(M){let m,q;return m=new jb({props:{$$slots:{default:[Pb]},$$scope:{ctx:M}}}),{c(){g(m.$$.fragment)},l(_){E(m.$$.fragment,_)},m(_,j){$(m,_,j),q=!0},p(_,j){const k={};j&2&&(k.$$scope={dirty:j,ctx:_}),m.$set(k)},i(_){q||(b(m.$$.fragment,_),q=!0)},o(_){x(m.$$.fragment,_),q=!1},d(_){y(m,_)}}}function Cb(M){let m,q,_,j,k,w,A,N,P,C,S,O,D;return m=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>)`}}),O=new z({props:{code:"python -m transformers.onnx --model=local-tf-checkpoint onnx/",highlighted:"python -m transformers.onnx --model=local-tf-checkpoint onnx/"}}),{c(){g(m.$$.fragment),q=c(),_=r("p"),j=t("Una vez que se guarda el checkpoint, podemos exportarlo a ONNX usando el argumento "),k=r("code"),w=t("--model"),A=t(`
del paquete `),N=r("code"),P=t("transformers.onnx"),C=t(" al directorio deseado:"),S=c(),g(O.$$.fragment)},l(v){E(m.$$.fragment,v),q=p(v),_=n(v,"P",{});var T=l(_);j=s(T,"Una vez que se guarda el checkpoint, podemos exportarlo a ONNX usando el argumento "),k=n(T,"CODE",{});var B=l(k);w=s(B,"--model"),B.forEach(o),A=s(T,`
del paquete `),N=n(T,"CODE",{});var G=l(N);P=s(G,"transformers.onnx"),G.forEach(o),C=s(T," al directorio deseado:"),T.forEach(o),S=p(v),E(O.$$.fragment,v)},m(v,T){$(m,v,T),d(v,q,T),d(v,_,T),a(_,j),a(_,k),a(k,w),a(_,A),a(_,N),a(N,P),a(_,C),d(v,S,T),$(O,v,T),D=!0},p:yb,i(v){D||(b(m.$$.fragment,v),b(O.$$.fragment,v),D=!0)},o(v){x(m.$$.fragment,v),x(O.$$.fragment,v),D=!1},d(v){y(m,v),v&&o(q),v&&o(_),v&&o(S),y(O,v)}}}function Db(M){let m,q;return m=new jb({props:{$$slots:{default:[Cb]},$$scope:{ctx:M}}}),{c(){g(m.$$.fragment)},l(_){E(m.$$.fragment,_)},m(_,j){$(m,_,j),q=!0},p(_,j){const k={};j&2&&(k.$$scope={dirty:j,ctx:_}),m.$set(k)},i(_){q||(b(m.$$.fragment,_),q=!0)},o(_){x(m.$$.fragment,_),q=!1},d(_){y(m,_)}}}function zb(M){let m,q;return{c(){m=r("p"),q=t(`Las caracter\xEDsticas que tienen un sufijo \u2018with-past\u2019 (por ejemplo, \u2018causal-lm-with-past\u2019) corresponden a topolog\xEDas
de modelo con estados ocultos precalculados (clave y valores en los bloques de atenci\xF3n) que se pueden usar para una
decodificaci\xF3n autorregresiva m\xE1s r\xE1pida.`)},l(_){m=n(_,"P",{});var j=l(m);q=s(j,`Las caracter\xEDsticas que tienen un sufijo \u2018with-past\u2019 (por ejemplo, \u2018causal-lm-with-past\u2019) corresponden a topolog\xEDas
de modelo con estados ocultos precalculados (clave y valores en los bloques de atenci\xF3n) que se pueden usar para una
decodificaci\xF3n autorregresiva m\xE1s r\xE1pida.`),j.forEach(o)},m(_,j){d(_,m,j),a(m,q)},d(_){_&&o(m)}}}function Sb(M){let m,q,_,j,k;return{c(){m=r("p"),q=t(`Una buena manera de implementar una configuraci\xF3n personalizada en ONNX es observar la implementaci\xF3n
existente en el archivo `),_=r("code"),j=t("configuration_<model_name>.py"),k=t(" de una arquitectura similar.")},l(w){m=n(w,"P",{});var A=l(m);q=s(A,`Una buena manera de implementar una configuraci\xF3n personalizada en ONNX es observar la implementaci\xF3n
existente en el archivo `),_=n(A,"CODE",{});var N=l(_);j=s(N,"configuration_<model_name>.py"),N.forEach(o),k=s(A," de una arquitectura similar."),A.forEach(o)},m(w,A){d(w,m,A),a(m,q),a(m,_),a(_,j),a(m,k)},d(w){w&&o(m)}}}function Lb(M){let m,q,_,j,k,w,A,N,P,C,S,O,D,v,T,B,G,$e,re,Ha,be,We,J;return{c(){m=r("p"),q=t("Observa que la propiedad "),_=r("code"),j=t("inputs"),k=t(" para "),w=r("code"),A=t("DistilBertOnnxConfig"),N=t(" devuelve un "),P=r("code"),C=t("OrderedDict"),S=t(`.
Esto nos asegura que las entradas coincidan con su posici\xF3n relativa dentro del m\xE9todo
`),O=r("code"),D=t("PreTrainedModel.forward()"),v=t(" al rastrear el grafo. Recomendamos usar un "),T=r("code"),B=t("OrderedDict"),G=t(`
para las propiedades `),$e=r("code"),re=t("inputs"),Ha=t(" y "),be=r("code"),We=t("outputs"),J=t(" al implementar configuraciones ONNX personalizadas.")},l(U){m=n(U,"P",{});var L=l(m);q=s(L,"Observa que la propiedad "),_=n(L,"CODE",{});var ne=l(_);j=s(ne,"inputs"),ne.forEach(o),k=s(L," para "),w=n(L,"CODE",{});var ft=l(w);A=s(ft,"DistilBertOnnxConfig"),ft.forEach(o),N=s(L," devuelve un "),P=n(L,"CODE",{});var Ve=l(P);C=s(Ve,"OrderedDict"),Ve.forEach(o),S=s(L,`.
Esto nos asegura que las entradas coincidan con su posici\xF3n relativa dentro del m\xE9todo
`),O=n(L,"CODE",{});var ht=l(O);D=s(ht,"PreTrainedModel.forward()"),ht.forEach(o),v=s(L," al rastrear el grafo. Recomendamos usar un "),T=n(L,"CODE",{});var Ua=l(T);B=s(Ua,"OrderedDict"),Ua.forEach(o),G=s(L,`
para las propiedades `),$e=n(L,"CODE",{});var H=l($e);re=s(H,"inputs"),H.forEach(o),Ha=s(L," y "),be=n(L,"CODE",{});var _t=l(be);We=s(_t,"outputs"),_t.forEach(o),J=s(L," al implementar configuraciones ONNX personalizadas."),L.forEach(o)},m(U,L){d(U,m,L),a(m,q),a(m,_),a(_,j),a(m,k),a(m,w),a(w,A),a(m,N),a(m,P),a(P,C),a(m,S),a(m,O),a(O,D),a(m,v),a(m,T),a(T,B),a(m,G),a(m,$e),a($e,re),a(m,Ha),a(m,be),a(be,We),a(m,J)},d(U){U&&o(m)}}}function Mb(M){let m,q,_,j,k,w,A,N;return{c(){m=r("p"),q=t("Todas las propiedades base y m\xE9todos asociados con "),_=r("code"),j=t("OnnxConfig"),k=t(` y las
otras clases de configuraci\xF3n se pueden sobreescribir si es necesario.
Consulte `),w=r("code"),A=t("BartOnnxConfig"),N=t(" para ver un ejemplo avanzado.")},l(P){m=n(P,"P",{});var C=l(m);q=s(C,"Todas las propiedades base y m\xE9todos asociados con "),_=n(C,"CODE",{});var S=l(_);j=s(S,"OnnxConfig"),S.forEach(o),k=s(C,` y las
otras clases de configuraci\xF3n se pueden sobreescribir si es necesario.
Consulte `),w=n(C,"CODE",{});var O=l(w);A=s(O,"BartOnnxConfig"),O.forEach(o),N=s(C," para ver un ejemplo avanzado."),C.forEach(o)},m(P,C){d(P,m,C),a(m,q),a(m,_),a(_,j),a(m,k),a(m,w),a(w,A),a(m,N)},d(P){P&&o(m)}}}function Ib(M){let m,q,_,j,k,w,A,N,P,C,S;return{c(){m=r("p"),q=t(`Si tu modelo tiene m\xE1s de 2GB, ver\xE1s que se crean muchos archivos adicionales durante la exportaci\xF3n.
Esto es `),_=r("em"),j=t("esperado"),k=t(" porque ONNX usa "),w=r("a"),A=t("B\xFAferes de protocolo"),N=t(`
para almacenar el modelo y \xE9stos tienen un l\xEDmite de tama\xF1o de 2 GB. Consulta la
`),P=r("a"),C=t("documentaci\xF3n de ONNX"),S=t(` para obtener
instrucciones sobre c\xF3mo cargar modelos con datos externos.`),this.h()},l(O){m=n(O,"P",{});var D=l(m);q=s(D,`Si tu modelo tiene m\xE1s de 2GB, ver\xE1s que se crean muchos archivos adicionales durante la exportaci\xF3n.
Esto es `),_=n(D,"EM",{});var v=l(_);j=s(v,"esperado"),v.forEach(o),k=s(D," porque ONNX usa "),w=n(D,"A",{href:!0,rel:!0});var T=l(w);A=s(T,"B\xFAferes de protocolo"),T.forEach(o),N=s(D,`
para almacenar el modelo y \xE9stos tienen un l\xEDmite de tama\xF1o de 2 GB. Consulta la
`),P=n(D,"A",{href:!0,rel:!0});var B=l(P);C=s(B,"documentaci\xF3n de ONNX"),B.forEach(o),S=s(D,` para obtener
instrucciones sobre c\xF3mo cargar modelos con datos externos.`),D.forEach(o),this.h()},h(){u(w,"href","https://developers.google.com/protocol-buffers/"),u(w,"rel","nofollow"),u(P,"href","https://github.com/onnx/onnx/blob/master/docs/ExternalData.md"),u(P,"rel","nofollow")},m(O,D){d(O,m,D),a(m,q),a(m,_),a(_,j),a(m,k),a(m,w),a(w,A),a(m,N),a(m,P),a(P,C),a(m,S)},d(O){O&&o(m)}}}function Bb(M){let m,q;return{c(){m=r("p"),q=t(`Este es el comienzo de nuestros experimentos con TorchScript y todav\xEDa estamos explorando sus capacidades con modelos de
tama\xF1o de entrada variable. Es un tema de inter\xE9s y profundizaremos nuestro an\xE1lisis en las pr\xF3ximas
versiones,  con m\xE1s ejemplos de c\xF3digo, una implementaci\xF3n m\xE1s flexible y puntos de referencia que comparen c\xF3digos
basados en Python con TorchScript compilado.`)},l(_){m=n(_,"P",{});var j=l(m);q=s(j,`Este es el comienzo de nuestros experimentos con TorchScript y todav\xEDa estamos explorando sus capacidades con modelos de
tama\xF1o de entrada variable. Es un tema de inter\xE9s y profundizaremos nuestro an\xE1lisis en las pr\xF3ximas
versiones,  con m\xE1s ejemplos de c\xF3digo, una implementaci\xF3n m\xE1s flexible y puntos de referencia que comparen c\xF3digos
basados en Python con TorchScript compilado.`),j.forEach(o)},m(_,j){d(_,m,j),a(m,q)},d(_){_&&o(m)}}}function Xb(M){let m,q,_,j,k,w,A,N,P,C,S,O,D,v,T,B,G,$e,re,Ha,be,We,J,U,L,ne,ft,Ve,ht,Ua,H,_t,Wa,Kc,Gc,is,Jc,Yc,ds,Qc,Zc,Fl,vt,ep,Hl,Ke,ap,cs,op,tp,Ul,gt,sp,Wl,f,ps,rp,np,us,lp,ip,ms,dp,cp,fs,pp,up,hs,mp,fp,_s,hp,_p,vs,vp,gp,gs,Ep,$p,Es,bp,xp,$s,yp,jp,bs,qp,wp,xs,kp,Tp,ys,Op,Np,js,Pp,Ap,qs,Cp,Dp,ws,zp,Sp,ks,Lp,Mp,Ts,Ip,Bp,Os,Xp,Rp,Ns,Fp,Hp,Ps,Up,Wp,As,Vp,Kp,Cs,Gp,Jp,Ds,Yp,Qp,zs,Zp,eu,Ss,au,ou,Ls,tu,su,Ms,ru,nu,Is,lu,iu,Bs,du,cu,Xs,pu,uu,Rs,mu,fu,Fs,hu,_u,Hs,vu,gu,Us,Eu,$u,Ws,bu,xu,Vs,yu,ju,Ks,qu,wu,Gs,ku,Tu,Js,Ou,Nu,Ys,Pu,Au,Qs,Cu,Du,Zs,zu,Su,er,Lu,Mu,ar,Iu,Bu,or,Xu,Ru,tr,Fu,Hu,sr,Uu,Wu,rr,Vu,Vl,Et,Ku,Kl,Ge,Va,Gu,nr,Ju,Yu,Qu,lr,Zu,Gl,xe,Je,ir,Ka,em,dr,am,Jl,$t,om,Yl,Ga,Ql,Ye,tm,cr,sm,rm,Zl,Ja,ei,bt,nm,ai,Ya,oi,xt,lm,ti,Qa,si,le,im,pr,dm,cm,ur,pm,um,ri,Q,mm,mr,fm,hm,Za,_m,vm,eo,gm,Em,ni,ao,li,Qe,$m,fr,bm,xm,ii,oo,di,Ze,ym,to,jm,qm,ci,so,pi,yt,wm,ui,ea,mi,ye,aa,hr,ro,km,_r,Tm,fi,oa,Om,vr,Nm,Pm,hi,ta,gr,no,Er,Am,Cm,$r,Dm,zm,X,lo,io,br,Sm,Lm,xr,Mm,Im,yr,jr,Bm,Xm,co,po,qr,Rm,Fm,wr,Hm,Um,kr,Tr,Wm,Vm,uo,Or,Nr,Km,Gm,Pr,Ar,Jm,Ym,mo,Cr,Dr,Qm,Zm,zr,Sr,ef,af,fo,ho,Lr,of,tf,Mr,sf,rf,Ir,Br,nf,lf,_o,Xr,Rr,df,cf,Fr,Hr,pf,uf,vo,Ur,Wr,mf,ff,Vr,Kr,hf,_i,sa,_f,Gr,vf,gf,vi,go,gi,ie,Ef,Jr,$f,bf,Yr,xf,yf,Ei,Eo,$i,jt,jf,bi,$o,xi,Z,qf,Qr,wf,kf,Zr,Tf,Of,en,Nf,Pf,yi,ra,ji,je,na,an,bo,Af,on,Cf,qi,qt,Df,wi,de,tn,zf,Sf,sn,Lf,Mf,rn,If,ki,wt,Bf,Ti,qe,la,nn,xo,Xf,ln,Rf,Oi,kt,Ff,Ni,ce,ia,Hf,dn,Uf,Wf,cn,Vf,Kf,da,Gf,pn,Jf,Yf,un,Qf,Zf,ca,eh,mn,ah,oh,fn,th,Pi,pa,Ai,pe,sh,hn,rh,nh,_n,lh,ih,Ci,yo,Di,W,dh,vn,ch,ph,gn,uh,mh,En,fh,hh,$n,_h,vh,zi,ua,Si,Tt,gh,Li,jo,Mi,Ot,Eh,Ii,qo,Bi,Nt,$h,Xi,wo,Ri,V,bh,bn,xh,yh,xn,jh,qh,yn,wh,kh,jn,Th,Oh,Fi,ko,Hi,ma,Ui,we,fa,qn,To,Nh,wn,Ph,Wi,ue,Ah,kn,Ch,Dh,Tn,zh,Sh,Vi,Oo,Ki,R,Lh,On,Mh,Ih,Nn,Bh,Xh,Pn,Rh,Fh,An,Hh,Uh,Cn,Wh,Vh,Gi,No,Ji,ha,Yi,ke,_a,Dn,Po,Kh,zn,Gh,Qi,me,Jh,Sn,Yh,Qh,Ln,Zh,e_,Zi,Ao,ed,va,a_,Mn,o_,t_,ad,Te,ga,In,Co,s_,Bn,r_,od,Pt,n_,td,fe,Do,l_,Xn,i_,d_,c_,At,p_,Rn,u_,m_,Ct,f_,Fn,h_,sd,Ea,__,zo,v_,g_,rd,Oe,$a,Hn,So,E_,Un,$_,nd,ba,ld,xa,b_,Lo,x_,y_,id,Dt,j_,dd,zt,q_,cd,ya,Wn,w_,k_,Mo,T_,Vn,O_,N_,pd,St,P_,ud,Ne,ja,Kn,Io,A_,Gn,C_,md,he,D_,Jn,z_,S_,Yn,L_,M_,fd,ee,I_,Qn,B_,X_,Zn,R_,F_,el,H_,U_,hd,qa,W_,al,V_,K_,_d,Pe,wa,ol,Bo,G_,tl,J_,vd,Lt,Y_,gd,Mt,Q_,Ed,It,sl,Z_,$d,ka,ev,rl,av,ov,bd,Bt,tv,xd,Ae,Ta,nl,Xo,sv,ll,rv,yd,Xt,nv,jd,Ce,Oa,il,Ro,lv,dl,iv,qd,Y,dv,cl,cv,pv,pl,uv,mv,ul,fv,hv,ml,_v,wd,Fo,kd,De,Na,fl,Ho,vv,hl,gv,Td,ae,Ev,_l,$v,bv,vl,xv,yv,gl,jv,qv,Od,Uo,Nd,ze,Pa,El,Wo,wv,$l,kv,Pd,Aa,Tv,bl,Ov,Nv,Ad,Vo,Cd,Se,Ca,xl,Ko,Pv,yl,Av,Dd,_e,Cv,Go,Dv,zv,Jo,Sv,Lv,zd,ve,jl,Mv,Iv,Rt,Bv,Yo,Xv,Rv,Le,Fv,Qo,Hv,Uv,Zo,Wv,Vv,Sd,Me,Da,ql,et,Kv,wl,Gv,Ld,F,Jv,Ie,Yv,kl,Qv,Zv,eg,at,ag,og,ot,tg,sg,tt,rg,ng,Be,lg,Tl,ig,dg,cg,Md,Xe,za,Ol,st,pg,Nl,ug,Id,Ft,mg,Bd,Ht,Re,fg,rt,hg,_g,nt,vg,gg,Xd,Fe,Sa,Pl,lt,Eg,Al,$g,Rd,oe,bg,it,xg,yg,Cl,jg,qg,Dl,wg,kg,Fd,dt,Hd,Ut,Tg,Ud,ct,Wd,Wt,Og,Vd,pt,Kd,Vt,Ng,Gd,La,Pg,ut,Ag,Cg,Jd;return w=new I({}),ne=new I({}),Ka=new I({}),Ga=new z({props:{code:"pip install transformers[onnx]",highlighted:"pip install transformers[onnx]"}}),Ja=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 tolerence 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 tolerence when validating the model.`}}),Ya=new z({props:{code:"python -m transformers.onnx --model=distilbert-base-uncased onnx/",highlighted:"python -m transformers.onnx --model=distilbert-base-uncased onnx/"}}),Qa=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`}}),ao=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))`}}),oo=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>]s`}}),so=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/"}}),ea=new Nb({props:{pytorch:!0,tensorflow:!0,jax:!1,$$slots:{tensorflow:[Db],pytorch:[Ab]},$$scope:{ctx:M}}}),ro=new I({}),go=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>]`}}),Eo=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/`}}),$o=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`}}),ra=new ls({props:{$$slots:{default:[zb]},$$scope:{ctx:M}}}),bo=new I({}),xo=new I({}),pa=new ls({props:{$$slots:{default:[Sb]},$$scope:{ctx:M}}}),yo=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>        )`}}),ua=new ls({props:{$$slots:{default:[Lb]},$$scope:{ctx:M}}}),jo=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)`}}),qo=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>`}}),wo=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>})])`}}),ko=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>})])`}}),ma=new ls({props:{$$slots:{default:[Mb]},$$scope:{ctx:M}}}),To=new I({}),Oo=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)`}}),No=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)`}}),ha=new ls({props:{$$slots:{default:[Ib]},$$scope:{ctx:M}}}),Po=new I({}),Ao=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>)`}}),Co=new I({}),So=new I({}),ba=new ls({props:{$$slots:{default:[Bb]},$$scope:{ctx:M}}}),Io=new I({}),Bo=new I({}),Xo=new I({}),Ro=new I({}),Fo=new z({props:{code:`from transformers import BertModel, BertTokenizer, BertConfig
import torch

enc = BertTokenizer.from_pretrained("bert-base-uncased")

# Tokenizing input text
text = "[CLS] Who was Jim Henson ? [SEP] Jim Henson was a puppeteer [SEP]"
tokenized_text = enc.tokenize(text)

# Masking one of the input tokens
masked_index = 8
tokenized_text[masked_index] = "[MASK]"
indexed_tokens = enc.convert_tokens_to_ids(tokenized_text)
segments_ids = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]

# Creating a dummy input
tokens_tensor = torch.tensor([indexed_tokens])
segments_tensors = torch.tensor([segments_ids])
dummy_input = [tokens_tensor, segments_tensors]

# Initializing the model with the torchscript flag
# Flag set to True even though it is not necessary as this model does not have an LM Head.
config = BertConfig(
    vocab_size_or_config_json_file=32000,
    hidden_size=768,
    num_hidden_layers=12,
    num_attention_heads=12,
    intermediate_size=3072,
    torchscript=True,
)

# Instantiating the model
model = BertModel(config)

# The model needs to be in evaluation mode
model.eval()

# If you are instantiating the model with *from_pretrained* you can also easily set the TorchScript flag
model = BertModel.from_pretrained("bert-base-uncased", torchscript=True)

# Creating the trace
traced_model = torch.jit.trace(model, [tokens_tensor, segments_tensors])
torch.jit.save(traced_model, "traced_bert.pt")`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> BertModel, BertTokenizer, BertConfig
<span class="hljs-keyword">import</span> torch

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

<span class="hljs-comment"># Tokenizing input text</span>
text = <span class="hljs-string">&quot;[CLS] Who was Jim Henson ? [SEP] Jim Henson was a puppeteer [SEP]&quot;</span>
tokenized_text = enc.tokenize(text)

<span class="hljs-comment"># Masking one of the input tokens</span>
masked_index = <span class="hljs-number">8</span>
tokenized_text[masked_index] = <span class="hljs-string">&quot;[MASK]&quot;</span>
indexed_tokens = enc.convert_tokens_to_ids(tokenized_text)
segments_ids = [<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>]

<span class="hljs-comment"># Creating a dummy input</span>
tokens_tensor = torch.tensor([indexed_tokens])
segments_tensors = torch.tensor([segments_ids])
dummy_input = [tokens_tensor, segments_tensors]

<span class="hljs-comment"># Initializing the model with the torchscript flag</span>
<span class="hljs-comment"># Flag set to True even though it is not necessary as this model does not have an LM Head.</span>
config = BertConfig(
    vocab_size_or_config_json_file=<span class="hljs-number">32000</span>,
    hidden_size=<span class="hljs-number">768</span>,
    num_hidden_layers=<span class="hljs-number">12</span>,
    num_attention_heads=<span class="hljs-number">12</span>,
    intermediate_size=<span class="hljs-number">3072</span>,
    torchscript=<span class="hljs-literal">True</span>,
)

<span class="hljs-comment"># Instantiating the model</span>
model = BertModel(config)

<span class="hljs-comment"># The model needs to be in evaluation mode</span>
model.<span class="hljs-built_in">eval</span>()

<span class="hljs-comment"># If you are instantiating the model with *from_pretrained* you can also easily set the TorchScript flag</span>
model = BertModel.from_pretrained(<span class="hljs-string">&quot;bert-base-uncased&quot;</span>, torchscript=<span class="hljs-literal">True</span>)

<span class="hljs-comment"># Creating the trace</span>
traced_model = torch.jit.trace(model, [tokens_tensor, segments_tensors])
torch.jit.save(traced_model, <span class="hljs-string">&quot;traced_bert.pt&quot;</span>)`}}),Ho=new I({}),Uo=new z({props:{code:`loaded_model = torch.jit.load("traced_bert.pt")
loaded_model.eval()

all_encoder_layers, pooled_output = loaded_model(*dummy_input)`,highlighted:`loaded_model = torch.jit.load(<span class="hljs-string">&quot;traced_bert.pt&quot;</span>)
loaded_model.<span class="hljs-built_in">eval</span>()

all_encoder_layers, pooled_output = loaded_model(*dummy_input)`}}),Wo=new I({}),Vo=new z({props:{code:"traced_model(tokens_tensor, segments_tensors)",highlighted:"traced_model(tokens_tensor, segments_tensors)"}}),Ko=new I({}),et=new I({}),st=new I({}),lt=new I({}),dt=new z({props:{code:`from transformers import BertModel, BertTokenizer, BertConfig
import torch
import torch.neuron`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> BertModel, BertTokenizer, BertConfig
<span class="hljs-keyword">import</span> torch
<span class="hljs-keyword">import</span> torch.neuron`}}),ct=new z({props:{code:"torch.jit.trace(model, [tokens_tensor, segments_tensors])",highlighted:"torch.jit.trace(model, [tokens_tensor, segments_tensors])"}}),pt=new z({props:{code:"torch.neuron.trace(model, [token_tensor, segments_tensors])",highlighted:"torch.neuron.trace(model, [token_tensor, segments_tensors])"}}),{c(){m=r("meta"),q=c(),_=r("h1"),j=r("a"),k=r("span"),g(w.$$.fragment),A=c(),N=r("span"),P=t("Exportar modelos \u{1F917} Transformers"),C=c(),S=r("p"),O=t(`Si necesitas implementar modelos \u{1F917} Transformers en entornos de producci\xF3n, te
recomendamos exportarlos a un formato serializado que se pueda cargar y ejecutar
en tiempos de ejecuci\xF3n y hardware especializados. En esta gu\xEDa, te mostraremos c\xF3mo
exportar modelos \u{1F917} Transformers en dos formatos ampliamente utilizados: ONNX y TorchScript.`),D=c(),v=r("p"),T=t(`Una vez exportado, un modelo puede optimizarse para la inferencia a trav\xE9s de t\xE9cnicas
como la cuantizaci\xF3n y `),B=r("em"),G=t("pruning"),$e=t(`. Si est\xE1s interesado en optimizar tus modelos para
que funcionen con la m\xE1xima eficiencia, consulta la
`),re=r("a"),Ha=t("biblioteca de \u{1F917} Optimum"),be=t("."),We=c(),J=r("h2"),U=r("a"),L=r("span"),g(ne.$$.fragment),ft=c(),Ve=r("span"),ht=t("ONNX"),Ua=c(),H=r("p"),_t=t("El proyecto "),Wa=r("a"),Kc=t("ONNX (Open Neural Network eXchange)"),Gc=t(` es un
est\xE1ndar abierto que define un conjunto com\xFAn de operadores y un formato
de archivo com\xFAn para representar modelos de aprendizaje profundo en una
amplia variedad de `),is=r("em"),Jc=t("frameworks"),Yc=t(`, incluidos PyTorch y TensorFlow. Cuando un modelo
se exporta al formato ONNX, estos operadores se usan para construir un
grafo computacional (a menudo llamado `),ds=r("em"),Qc=t("representaci\xF3n intermedia"),Zc=t(`) que
representa el flujo de datos a trav\xE9s de la red neuronal.`),Fl=c(),vt=r("p"),ep=t(`Al exponer un grafo con operadores y tipos de datos estandarizados, ONNX facilita
el cambio entre frameworks. Por ejemplo, un modelo entrenado en PyTorch se puede
exportar a formato ONNX y luego importar en TensorFlow (y viceversa).`),Hl=c(),Ke=r("p"),ap=t("\u{1F917} Transformers proporciona un paquete llamado "),cs=r("code"),op=t("transformers.onnx"),tp=t(`, el cual permite convertir
los checkpoints de un modelo en un grafo ONNX aprovechando los objetos de configuraci\xF3n.
Estos objetos de configuraci\xF3n est\xE1n hechos a la medida de diferentes arquitecturas de modelos
y est\xE1n dise\xF1ados para ser f\xE1cilmente extensibles a otras arquitecturas.`),Ul=c(),gt=r("p"),sp=t("Las configuraciones a la medida incluyen las siguientes arquitecturas:"),Wl=c(),f=r("ul"),ps=r("li"),rp=t("ALBERT"),np=c(),us=r("li"),lp=t("BART"),ip=c(),ms=r("li"),dp=t("BEiT"),cp=c(),fs=r("li"),pp=t("BERT"),up=c(),hs=r("li"),mp=t("BigBird"),fp=c(),_s=r("li"),hp=t("BigBird-Pegasus"),_p=c(),vs=r("li"),vp=t("Blenderbot"),gp=c(),gs=r("li"),Ep=t("BlenderbotSmall"),$p=c(),Es=r("li"),bp=t("BLOOM"),xp=c(),$s=r("li"),yp=t("CamemBERT"),jp=c(),bs=r("li"),qp=t("CLIP"),wp=c(),xs=r("li"),kp=t("CodeGen"),Tp=c(),ys=r("li"),Op=t("ConvBERT"),Np=c(),js=r("li"),Pp=t("ConvNeXT"),Ap=c(),qs=r("li"),Cp=t("Data2VecText"),Dp=c(),ws=r("li"),zp=t("Data2VecVision"),Sp=c(),ks=r("li"),Lp=t("DeBERTa"),Mp=c(),Ts=r("li"),Ip=t("DeBERTa-v2"),Bp=c(),Os=r("li"),Xp=t("DeiT"),Rp=c(),Ns=r("li"),Fp=t("DETR"),Hp=c(),Ps=r("li"),Up=t("DistilBERT"),Wp=c(),As=r("li"),Vp=t("ELECTRA"),Kp=c(),Cs=r("li"),Gp=t("FlauBERT"),Jp=c(),Ds=r("li"),Yp=t("GPT Neo"),Qp=c(),zs=r("li"),Zp=t("GPT-J"),eu=c(),Ss=r("li"),au=t("I-BERT"),ou=c(),Ls=r("li"),tu=t("LayoutLM"),su=c(),Ms=r("li"),ru=t("LayoutLMv3"),nu=c(),Is=r("li"),lu=t("LeViT"),iu=c(),Bs=r("li"),du=t("LongT5"),cu=c(),Xs=r("li"),pu=t("M2M100"),uu=c(),Rs=r("li"),mu=t("Marian"),fu=c(),Fs=r("li"),hu=t("mBART"),_u=c(),Hs=r("li"),vu=t("MobileBERT"),gu=c(),Us=r("li"),Eu=t("MobileViT"),$u=c(),Ws=r("li"),bu=t("MT5"),xu=c(),Vs=r("li"),yu=t("OpenAI GPT-2"),ju=c(),Ks=r("li"),qu=t("Perceiver"),wu=c(),Gs=r("li"),ku=t("PLBart"),Tu=c(),Js=r("li"),Ou=t("ResNet"),Nu=c(),Ys=r("li"),Pu=t("RoBERTa"),Au=c(),Qs=r("li"),Cu=t("RoFormer"),Du=c(),Zs=r("li"),zu=t("SqueezeBERT"),Su=c(),er=r("li"),Lu=t("T5"),Mu=c(),ar=r("li"),Iu=t("ViT"),Bu=c(),or=r("li"),Xu=t("XLM"),Ru=c(),tr=r("li"),Fu=t("XLM-RoBERTa"),Hu=c(),sr=r("li"),Uu=t("XLM-RoBERTa-XL"),Wu=c(),rr=r("li"),Vu=t("YOLOS"),Vl=c(),Et=r("p"),Ku=t("En las pr\xF3ximas dos secciones, te mostraremos c\xF3mo:"),Kl=c(),Ge=r("ul"),Va=r("li"),Gu=t("Exportar un modelo compatible utilizando el paquete "),nr=r("code"),Ju=t("transformers.onnx"),Yu=t("."),Qu=c(),lr=r("li"),Zu=t("Exportar un modelo personalizado para una arquitectura no compatible."),Gl=c(),xe=r("h3"),Je=r("a"),ir=r("span"),g(Ka.$$.fragment),em=c(),dr=r("span"),am=t("Exportar un model a ONNX"),Jl=c(),$t=r("p"),om=t(`Para exportar un modelo \u{1F917} Transformers a ONNX, tienes que instalar primero algunas
dependencias extra:`),Yl=c(),g(Ga.$$.fragment),Ql=c(),Ye=r("p"),tm=t("El paquete "),cr=r("code"),sm=t("transformers.onnx"),rm=t(" puede ser usado luego como un m\xF3dulo de Python:"),Zl=c(),g(Ja.$$.fragment),ei=c(),bt=r("p"),nm=t("Exportar un checkpoint usando una configuraci\xF3n a la medida se puede hacer de la siguiente manera:"),ai=c(),g(Ya.$$.fragment),oi=c(),xt=r("p"),lm=t("que deber\xEDa mostrar los siguientes registros:"),ti=c(),g(Qa.$$.fragment),si=c(),le=r("p"),im=t("Esto exporta un grafo ONNX del checkpoint definido por el argumento "),pr=r("code"),dm=t("--model"),cm=t(`.
En este ejemplo, es un modelo `),ur=r("code"),pm=t("distilbert-base-uncased"),um=t(`, pero puede ser cualquier
checkpoint en Hugging Face Hub o que est\xE9 almacenado localmente.`),ri=c(),Q=r("p"),mm=t("El archivo "),mr=r("code"),fm=t("model.onnx"),hm=t(` resultante se puede ejecutar en uno de los
`),Za=r("a"),_m=t("muchos aceleradores"),vm=t(`
que admiten el est\xE1ndar ONNX. Por ejemplo, podemos cargar y ejecutar el
modelo con `),eo=r("a"),gm=t("ONNX Runtime"),Em=t(" de la siguiente manera:"),ni=c(),g(ao.$$.fragment),li=c(),Qe=r("p"),$m=t("Los nombres necesarios de salida (es decir, "),fr=r("code"),bm=t('["last_hidden_state"]'),xm=t(`) se pueden obtener
echando un vistazo a la configuraci\xF3n ONNX de cada modelo. Por ejemplo, para DistilBERT tenemos:`),ii=c(),g(oo.$$.fragment),di=c(),Ze=r("p"),ym=t(`El proceso es id\xE9ntico para los checkpoints de TensorFlow en Hub.
Por ejemplo, podemos exportar un checkpoint puro de TensorFlow desde
`),to=r("a"),jm=t("Keras"),qm=t(" de la siguiente manera:"),ci=c(),g(so.$$.fragment),pi=c(),yt=r("p"),wm=t(`Para exportar un modelo que est\xE1 almacenado localmente, deber\xE1s tener los pesos
y tokenizadores del modelo almacenados en un directorio. Por ejemplo, podemos cargar
y guardar un checkpoint de la siguiente manera:`),ui=c(),g(ea.$$.fragment),mi=c(),ye=r("h3"),aa=r("a"),hr=r("span"),g(ro.$$.fragment),km=c(),_r=r("span"),Tm=t("Seleccionar caracter\xEDsticas para diferentes topolog\xEDas de un modelo"),fi=c(),oa=r("p"),Om=t("Cada configuraci\xF3n a la medida viene con un conjunto de "),vr=r("em"),Nm=t("caracter\xEDsticas"),Pm=t(` que te permiten exportar
modelos para diferentes tipos de topolog\xEDas o tareas. Como se muestra en la siguiente tabla, cada
funci\xF3n est\xE1 asociada con una auto-clase de autom\xF3vil diferente:`),hi=c(),ta=r("table"),gr=r("thead"),no=r("tr"),Er=r("th"),Am=t("Feature"),Cm=c(),$r=r("th"),Dm=t("Auto Class"),zm=c(),X=r("tbody"),lo=r("tr"),io=r("td"),br=r("code"),Sm=t("causal-lm"),Lm=t(", "),xr=r("code"),Mm=t("causal-lm-with-past"),Im=c(),yr=r("td"),jr=r("code"),Bm=t("AutoModelForCausalLM"),Xm=c(),co=r("tr"),po=r("td"),qr=r("code"),Rm=t("default"),Fm=t(", "),wr=r("code"),Hm=t("default-with-past"),Um=c(),kr=r("td"),Tr=r("code"),Wm=t("AutoModel"),Vm=c(),uo=r("tr"),Or=r("td"),Nr=r("code"),Km=t("masked-lm"),Gm=c(),Pr=r("td"),Ar=r("code"),Jm=t("AutoModelForMaskedLM"),Ym=c(),mo=r("tr"),Cr=r("td"),Dr=r("code"),Qm=t("question-answering"),Zm=c(),zr=r("td"),Sr=r("code"),ef=t("AutoModelForQuestionAnswering"),af=c(),fo=r("tr"),ho=r("td"),Lr=r("code"),of=t("seq2seq-lm"),tf=t(", "),Mr=r("code"),sf=t("seq2seq-lm-with-past"),rf=c(),Ir=r("td"),Br=r("code"),nf=t("AutoModelForSeq2SeqLM"),lf=c(),_o=r("tr"),Xr=r("td"),Rr=r("code"),df=t("sequence-classification"),cf=c(),Fr=r("td"),Hr=r("code"),pf=t("AutoModelForSequenceClassification"),uf=c(),vo=r("tr"),Ur=r("td"),Wr=r("code"),mf=t("token-classification"),ff=c(),Vr=r("td"),Kr=r("code"),hf=t("AutoModelForTokenClassification"),_i=c(),sa=r("p"),_f=t("Para cada configuraci\xF3n, puedes encontrar la lista de funciones admitidas a trav\xE9s de "),Gr=r("code"),vf=t("FeaturesManager"),gf=t(`.
Por ejemplo, para DistilBERT tenemos:`),vi=c(),g(go.$$.fragment),gi=c(),ie=r("p"),Ef=t("Le puedes pasar una de estas caracter\xEDsticas al argumento "),Jr=r("code"),$f=t("--feature"),bf=t(" en el paquete "),Yr=r("code"),xf=t("transformers.onnx"),yf=t(`.
Por ejemplo, para exportar un modelo de clasificaci\xF3n de texto, podemos elegir un modelo ya ajustado del Hub y ejecutar:`),Ei=c(),g(Eo.$$.fragment),$i=c(),jt=r("p"),jf=t("que mostrar\xE1 los siguientes registros:"),bi=c(),g($o.$$.fragment),xi=c(),Z=r("p"),qf=t("Ten en cuenta que, en este caso, los nombres de salida del modelo ajustado son "),Qr=r("code"),wf=t("logits"),kf=t(" en lugar de "),Zr=r("code"),Tf=t("last_hidden_state"),Of=t(`
que vimos anteriormente con el checkpoint `),en=r("code"),Nf=t("distilbert-base-uncased"),Pf=t(`. Esto es de esperarse ya que el modelo ajustado
tiene un cabezal de clasificaci\xF3n secuencial.`),yi=c(),g(ra.$$.fragment),ji=c(),je=r("h3"),na=r("a"),an=r("span"),g(bo.$$.fragment),Af=c(),on=r("span"),Cf=t("Exportar un modelo para una arquitectura no compatible"),qi=c(),qt=r("p"),Df=t(`Si deseas exportar un modelo cuya arquitectura no es compatible de forma nativa
con la biblioteca, debes seguir tres pasos principales:`),wi=c(),de=r("ol"),tn=r("li"),zf=t("Implementa una configuraci\xF3n personalizada en ONNX."),Sf=c(),sn=r("li"),Lf=t("Exporta el modelo a ONNX."),Mf=c(),rn=r("li"),If=t("Valide los resultados de PyTorch y los modelos exportados."),ki=c(),wt=r("p"),Bf=t(`En esta secci\xF3n, veremos c\xF3mo se implement\xF3 la serializaci\xF3n de DistilBERT
para mostrar lo que implica cada paso.`),Ti=c(),qe=r("h4"),la=r("a"),nn=r("span"),g(xo.$$.fragment),Xf=c(),ln=r("span"),Rf=t("Implementar una configuraci\xF3n personalizada en ONNX"),Oi=c(),kt=r("p"),Ff=t(`Comencemos con el objeto de configuraci\xF3n de ONNX. Proporcionamos tres clases abstractas
de las que debe heredar, seg\xFAn el tipo de arquitectura del modelo que quieras exportar:`),Ni=c(),ce=r("ul"),ia=r("li"),Hf=t("Modelos basados en el "),dn=r("em"),Uf=t("Encoder"),Wf=t(" inherente de "),cn=r("code"),Vf=t("OnnxConfig"),Kf=c(),da=r("li"),Gf=t("Modelos basados en el "),pn=r("em"),Jf=t("Decoder"),Yf=t(" inherente de "),un=r("code"),Qf=t("OnnxConfigWithPast"),Zf=c(),ca=r("li"),eh=t("Modelos "),mn=r("em"),ah=t("Encoder-decoder"),oh=t(" inherente de "),fn=r("code"),th=t("OnnxSeq2SeqConfigWithPast"),Pi=c(),g(pa.$$.fragment),Ai=c(),pe=r("p"),sh=t("Dado que DistilBERT es un modelo de tipo "),hn=r("em"),rh=t("encoder"),nh=t(", su configuraci\xF3n se hereda de "),_n=r("code"),lh=t("OnnxConfig"),ih=t(":"),Ci=c(),g(yo.$$.fragment),Di=c(),W=r("p"),dh=t("Cada objeto de configuraci\xF3n debe implementar la propiedad "),vn=r("code"),ch=t("inputs"),ph=t(` y devolver un mapeo,
donde cada llave corresponde a una entrada esperada y cada valor indica el eje de esa entrada.
Para DistilBERT, podemos ver que se requieren dos entradas: `),gn=r("code"),uh=t("input_ids"),mh=t(" y "),En=r("code"),fh=t("attention_mask"),hh=t(`.
Estas entradas tienen la misma forma de `),$n=r("code"),_h=t("(batch_size, sequence_length)"),vh=t(`, es por lo que vemos
los mismos ejes utilizados en la configuraci\xF3n.`),zi=c(),g(ua.$$.fragment),Si=c(),Tt=r("p"),gh=t(`Una vez que hayas implementado una configuraci\xF3n ONNX, puedes crear una
instancia proporcionando la configuraci\xF3n del modelo base de la siguiente manera:`),Li=c(),g(jo.$$.fragment),Mi=c(),Ot=r("p"),Eh=t(`El objeto resultante tiene varias propiedades \xFAtiles. Por ejemplo, puedes ver el conjunto de operadores ONNX que se
utilizar\xE1 durante la exportaci\xF3n:`),Ii=c(),g(qo.$$.fragment),Bi=c(),Nt=r("p"),$h=t("Tambi\xE9n puedes ver los resultados asociados con el modelo de la siguiente manera:"),Xi=c(),g(wo.$$.fragment),Ri=c(),V=r("p"),bh=t(`Observa que la propiedad de salidas sigue la misma estructura que las entradas;
devuelve un objecto `),bn=r("code"),xh=t("OrderedDict"),yh=t(` de salidas nombradas y sus formas. La estructura
de salida est\xE1 vinculada a la elecci\xF3n de la funci\xF3n con la que se inicializa la configuraci\xF3n.
Por defecto, la configuraci\xF3n de ONNX se inicializa con la funci\xF3n `),xn=r("code"),jh=t("default"),qh=t(` que
corresponde a exportar un modelo cargado con la clase `),yn=r("code"),wh=t("AutoModel"),kh=t(`. Si quieres exportar
una topolog\xEDa de modelo diferente, simplemente proporciona una caracter\xEDstica diferente
al argumento `),jn=r("code"),Th=t("task"),Oh=t(` cuando inicialices la configuraci\xF3n de ONNX. Por ejemplo, si quisi\xE9ramos
exportar DistilBERT con un cabezal de clasificaci\xF3n de secuencias, podr\xEDamos usar:`),Fi=c(),g(ko.$$.fragment),Hi=c(),g(ma.$$.fragment),Ui=c(),we=r("h4"),fa=r("a"),qn=r("span"),g(To.$$.fragment),Nh=c(),wn=r("span"),Ph=t("Exportar el modelo"),Wi=c(),ue=r("p"),Ah=t(`Una vez que hayas implementado la configuraci\xF3n de ONNX, el siguiente paso es exportar el modelo.
Aqu\xED podemos usar la funci\xF3n `),kn=r("code"),Ch=t("export()"),Dh=t(" proporcionada por el paquete "),Tn=r("code"),zh=t("transformers.onnx"),Sh=t(`.
Esta funci\xF3n espera la configuraci\xF3n de ONNX, junto con el modelo base y el tokenizador,
y la ruta para guardar el archivo exportado:`),Vi=c(),g(Oo.$$.fragment),Ki=c(),R=r("p"),Lh=t("Los objetos "),On=r("code"),Mh=t("onnx_inputs"),Ih=t(" y "),Nn=r("code"),Bh=t("onnx_outputs"),Xh=t(" devueltos por la funci\xF3n "),Pn=r("code"),Rh=t("export()"),Fh=t(`
son listas de llaves definidas en las propiedades `),An=r("code"),Hh=t("inputs"),Uh=t(" y "),Cn=r("code"),Wh=t("outputs"),Vh=t(` de la configuraci\xF3n.
Una vez exportado el modelo, puedes probar que el modelo est\xE1 bien formado de la siguiente manera:`),Gi=c(),g(No.$$.fragment),Ji=c(),g(ha.$$.fragment),Yi=c(),ke=r("h4"),_a=r("a"),Dn=r("span"),g(Po.$$.fragment),Kh=c(),zn=r("span"),Gh=t("Validar los resultados del modelo"),Qi=c(),me=r("p"),Jh=t(`El paso final es validar que los resultados del modelo base y exportado coincidan dentro
de cierta tolerancia absoluta. Aqu\xED podemos usar la funci\xF3n `),Sn=r("code"),Yh=t("validate_model_outputs()"),Qh=t(`
proporcionada por el paquete `),Ln=r("code"),Zh=t("transformers.onnx"),e_=t(" de la siguiente manera:"),Zi=c(),g(Ao.$$.fragment),ed=c(),va=r("p"),a_=t("Esta funci\xF3n usa el m\xE9todo "),Mn=r("code"),o_=t("OnnxConfig.generate_dummy_inputs()"),t_=t(` para generar entradas para el modelo base
y exportado, y la tolerancia absoluta se puede definir en la configuraci\xF3n. En general, encontramos una
concordancia num\xE9rica en el rango de 1e-6 a 1e-4, aunque es probable que cualquier valor menor que 1e-3 est\xE9 bien.`),ad=c(),Te=r("h3"),ga=r("a"),In=r("span"),g(Co.$$.fragment),s_=c(),Bn=r("span"),r_=t("Contribuir con una nueva configuraci\xF3n a \u{1F917} Transformers"),od=c(),Pt=r("p"),n_=t(`\xA1Estamos buscando expandir el conjunto de configuraciones a la medida para usar y agradecemos las contribuciones de la comunidad!
Si deseas contribuir con su colaboraci\xF3n a la biblioteca, deber\xE1s:`),td=c(),fe=r("ul"),Do=r("li"),l_=t("Implementa la configuraci\xF3n de ONNX en el archivo "),Xn=r("code"),i_=t("configuration_<model_name>.py"),d_=t(" correspondiente"),c_=c(),At=r("li"),p_=t("Incluye la arquitectura del modelo y las caracter\xEDsticas correspondientes en "),Rn=r("code"),u_=t("~onnx.features.FeatureManager"),m_=c(),Ct=r("li"),f_=t("Agrega tu arquitectura de modelo a las pruebas en "),Fn=r("code"),h_=t("test_onnx_v2.py"),sd=c(),Ea=r("p"),__=t("Revisa c\xF3mo fue la contribuci\xF3n para la "),zo=r("a"),v_=t("configuraci\xF3n de IBERT"),g_=t(`
y as\xED tener una idea de lo que necesito.`),rd=c(),Oe=r("h2"),$a=r("a"),Hn=r("span"),g(So.$$.fragment),E_=c(),Un=r("span"),$_=t("TorchScript"),nd=c(),g(ba.$$.fragment),ld=c(),xa=r("p"),b_=t(`Seg\xFAn la documentaci\xF3n de PyTorch: \u201CTorchScript es una forma de crear modelos serializables y optimizables a partir del
c\xF3digo de PyTorch\u201D. Los dos m\xF3dulos de Pytorch `),Lo=r("a"),x_=t("JIT y TRACE"),y_=t(` permiten al
desarrollador exportar su modelo para reutilizarlo  en otros programas, como los programas C++ orientados a la eficiencia.`),id=c(),Dt=r("p"),j_=t(`Hemos proporcionado una interfaz que permite exportar modelos de \u{1F917} Transformers a TorchScript para que puedan reutilizarse
en un entorno diferente  al de un programa Python basado en PyTorch. Aqu\xED explicamos c\xF3mo exportar y usar nuestros modelos
usando TorchScript.`),dd=c(),zt=r("p"),q_=t("Exportar un modelo requiere de dos cosas:"),cd=c(),ya=r("ul"),Wn=r("li"),w_=t("un pase hacia adelante con entradas ficticias."),k_=c(),Mo=r("li"),T_=t("instanciaci\xF3n del modelo con la indicador "),Vn=r("code"),O_=t("torchscript"),N_=t("."),pd=c(),St=r("p"),P_=t("Estas necesidades implican varias cosas con las que los desarrolladores deben tener cuidado. \xC9stas se detallan a continuaci\xF3n."),ud=c(),Ne=r("h3"),ja=r("a"),Kn=r("span"),g(Io.$$.fragment),A_=c(),Gn=r("span"),C_=t("Indicador de TorchScript y pesos atados"),md=c(),he=r("p"),D_=t(`Este indicador es necesario porque la mayor\xEDa de los modelos de lenguaje en este repositorio tienen pesos vinculados entre su capa
de `),Jn=r("code"),z_=t("Embedding"),S_=t(" y su capa de "),Yn=r("code"),L_=t("Decoding"),M_=t(`. TorchScript no permite la exportaci\xF3n de modelos que tengan pesos atados, por lo que es
necesario desvincular y clonar los pesos previamente.`),fd=c(),ee=r("p"),I_=t("Esto implica que los modelos instanciados con el indicador "),Qn=r("code"),B_=t("torchscript"),X_=t(" tienen su capa "),Zn=r("code"),R_=t("Embedding"),F_=t(" y "),el=r("code"),H_=t("Decoding"),U_=t(` separadas,
lo que significa que no deben entrenarse m\xE1s adelante. El entrenamiento desincronizar\xEDa las dos capas, lo que generar\xEDa
resultados inesperados.`),hd=c(),qa=r("p"),W_=t(`Este no es el caso de los modelos que no tienen un cabezal de modelo de lenguaje, ya que no tienen pesos atados.
Estos modelos se pueden exportar de forma segura sin el indicador `),al=r("code"),V_=t("torchscript"),K_=t("."),_d=c(),Pe=r("h3"),wa=r("a"),ol=r("span"),g(Bo.$$.fragment),G_=c(),tl=r("span"),J_=t("Entradas ficticias y longitudes est\xE1ndar"),vd=c(),Lt=r("p"),Y_=t(`Las entradas ficticias se utilizan para crear un modelo de pase hacia adelante. Mientras los valores de las entradas se
propagan a trav\xE9s de las capas, PyTorch realiza un seguimiento de las diferentes operaciones ejecutadas en cada tensor.
Estas operaciones registradas se utilizan luego para crear el \u201Crastro\u201D del modelo.`),gd=c(),Mt=r("p"),Q_=t(`El rastro se crea en relaci\xF3n con las dimensiones de las entradas. Por lo tanto, est\xE1 limitado por las dimensiones de la
entrada ficticia y no funcionar\xE1 para ninguna otra longitud de secuencia o tama\xF1o de lote. Al intentar con un tama\xF1o diferente,
un error como:`),Ed=c(),It=r("p"),sl=r("code"),Z_=t("The expanded size of the tensor (3) must match the existing size (7) at non-singleton dimension 2"),$d=c(),ka=r("p"),ev=t(`aparecer\xE1. Por lo tanto, se recomienda rastrear el modelo con un tama\xF1o de entrada ficticia al menos tan grande como la
entrada m\xE1s  grande que se alimentar\xE1 al modelo durante la inferencia. El `),rl=r("em"),av=t("padding"),ov=t(` se puede realizar para completar los
valores que faltan.  Sin embargo, como el modelo se habr\xE1 rastreado con un tama\xF1o de entrada grande, las dimensiones de
las diferentes matrices tambi\xE9n ser\xE1n grandes, lo que dar\xE1 como resultado m\xE1s c\xE1lculos.`),bd=c(),Bt=r("p"),tv=t(`Se recomienda tener cuidado con el n\xFAmero total de operaciones realizadas en cada entrada y seguir de cerca el rendimiento
al exportar modelos de longitud de secuencia variable.`),xd=c(),Ae=r("h3"),Ta=r("a"),nl=r("span"),g(Xo.$$.fragment),sv=c(),ll=r("span"),rv=t("Usar TorchScript en Python"),yd=c(),Xt=r("p"),nv=t("A continuaci\xF3n se muestra un ejemplo que muestra c\xF3mo guardar, cargar modelos y c\xF3mo usar el rastreo para la inferencia."),jd=c(),Ce=r("h4"),Oa=r("a"),il=r("span"),g(Ro.$$.fragment),lv=c(),dl=r("span"),iv=t("Guardando un modelo"),qd=c(),Y=r("p"),dv=t("Este fragmento muestra c\xF3mo usar TorchScript para exportar un "),cl=r("code"),cv=t("BertModel"),pv=t(". Aqu\xED, el "),pl=r("code"),uv=t("BertModel"),mv=t(` se instancia de acuerdo
con la clase `),ul=r("code"),fv=t("BertConfig"),hv=t(" y luego se guarda en el disco con el nombre de archivo "),ml=r("code"),_v=t("traced_bert.pt"),wd=c(),g(Fo.$$.fragment),kd=c(),De=r("h4"),Na=r("a"),fl=r("span"),g(Ho.$$.fragment),vv=c(),hl=r("span"),gv=t("Cargar un modelo"),Td=c(),ae=r("p"),Ev=t("Este fragmento muestra c\xF3mo cargar el "),_l=r("code"),$v=t("BertModel"),bv=t(" que se guard\xF3 previamente en el disco con el nombre "),vl=r("code"),xv=t("traced_bert.pt"),yv=t(`.
Estamos reutilizando el `),gl=r("code"),jv=t("dummy_input"),qv=t(" previamente inicializado."),Od=c(),g(Uo.$$.fragment),Nd=c(),ze=r("h4"),Pa=r("a"),El=r("span"),g(Wo.$$.fragment),wv=c(),$l=r("span"),kv=t("Usar un modelo rastreado para la inferencia"),Pd=c(),Aa=r("p"),Tv=t("Usar el modelo rastreado para la inferencia es tan simple como usar su m\xE9todo "),bl=r("code"),Ov=t("__call__"),Nv=t(":"),Ad=c(),g(Vo.$$.fragment),Cd=c(),Se=r("h3"),Ca=r("a"),xl=r("span"),g(Ko.$$.fragment),Pv=c(),yl=r("span"),Av=t("Implementar los modelos HuggingFace TorchScript en AWS mediante Neuron SDK"),Dd=c(),_e=r("p"),Cv=t("AWS present\xF3 la familia de instancias "),Go=r("a"),Dv=t("Amazon EC2 Inf1"),zv=t(` para la inferencia
de aprendizaje autom\xE1tico de bajo costo y  alto rendimiento en la nube. Las instancias Inf1 funcionan con el chip AWS
Inferentia, un acelerador de hardware personalizado,  que se especializa en cargas de trabajo de inferencia de aprendizaje
profundo. `),Jo=r("a"),Sv=t("AWS Neuron"),Lv=t(` es el kit de desarrollo para  Inferentia
que admite el rastreo y la optimizaci\xF3n de modelos de  transformers para su implementaci\xF3n en Inf1. El SDK de Neuron proporciona:`),zd=c(),ve=r("ol"),jl=r("li"),Mv=t("API f\xE1cil de usar con una l\xEDnea de cambio de c\xF3digo para rastrear y optimizar un modelo de TorchScript para la inferencia en la nube."),Iv=c(),Rt=r("li"),Bv=t("Optimizaciones de rendimiento listas para usar con un "),Yo=r("a"),Xv=t("costo-rendimiento mejorado"),Rv=c(),Le=r("li"),Fv=t("Soporte para modelos HuggingFace Transformers construidos con "),Qo=r("a"),Hv=t("PyTorch"),Uv=t(`
o `),Zo=r("a"),Wv=t("TensorFlow"),Vv=t("."),Sd=c(),Me=r("h4"),Da=r("a"),ql=r("span"),g(et.$$.fragment),Kv=c(),wl=r("span"),Gv=t("Implicaciones"),Ld=c(),F=r("p"),Jv=t(`Los modelos Transformers basados en la arquitectura
`),Ie=r("a"),Yv=t("BERT (Representaciones de "),kl=r("em"),Qv=t("Enconder"),Zv=t(" bidireccional de Transformers)"),eg=t(`,
o sus variantes, como `),at=r("a"),ag=t("distilBERT"),og=t(` y
`),ot=r("a"),tg=t("roBERTa"),sg=t(`, se ejecutar\xE1n mejor en Inf1 para tareas no
generativas, como la respuesta extractiva de preguntas, la clasificaci\xF3n de secuencias y la clasificaci\xF3n de tokens.
Como alternativa, las tareas de generaci\xF3n de texto se pueden adaptar para ejecutarse en Inf1, seg\xFAn este
`),tt=r("a"),rg=t("tutorial de AWS Neuron MarianMT"),ng=t(`.
Puedes encontrar m\xE1s informaci\xF3n sobre los modelos que est\xE1n listos para usarse en Inferentia en la
`),Be=r("a"),lg=t("secci\xF3n "),Tl=r("em"),ig=t("Model Architecture Fit"),dg=t(" de la documentaci\xF3n de Neuron"),cg=t("."),Md=c(),Xe=r("h4"),za=r("a"),Ol=r("span"),g(st.$$.fragment),pg=c(),Nl=r("span"),ug=t("Dependencias"),Id=c(),Ft=r("p"),mg=t("Usar AWS Neuron para convertir modelos requiere las siguientes dependencias y entornos:"),Bd=c(),Ht=r("ul"),Re=r("li"),fg=t("Un "),rt=r("a"),hg=t("entorno Neuron SDK"),_g=t(`,
que viene preconfigurado en `),nt=r("a"),vg=t("AWS Deep Learning AMI"),gg=t("."),Xd=c(),Fe=r("h4"),Sa=r("a"),Pl=r("span"),g(lt.$$.fragment),Eg=c(),Al=r("span"),$g=t("Convertir un modelo a AWS Neuron"),Rd=c(),oe=r("p"),bg=t("Con el mismo script usado en "),it=r("a"),xg=t("Uso de TorchScript en Python"),yg=t(`
para rastrear un \u201CBertModel\u201D, puedes importar la extensi\xF3n del `),Cl=r("em"),jg=t("framework"),qg=c(),Dl=r("code"),wg=t("torch.neuron"),kg=t(` para acceder a los componentes
del SDK de Neuron a trav\xE9s de una API de Python.`),Fd=c(),g(dt.$$.fragment),Hd=c(),Ut=r("p"),Tg=t("Y modificando la l\xEDnea de c\xF3digo de rastreo de:"),Ud=c(),g(ct.$$.fragment),Wd=c(),Wt=r("p"),Og=t("con lo siguiente:"),Vd=c(),g(pt.$$.fragment),Kd=c(),Vt=r("p"),Ng=t("Este cambio permite a Neuron SDK rastrear el modelo y optimizarlo para ejecutarse en instancias Inf1."),Gd=c(),La=r("p"),Pg=t(`Para obtener m\xE1s informaci\xF3n sobre las funciones, las herramientas, los tutoriales de ejemplo y las \xFAltimas actualizaciones
de AWS Neuron SDK, consulte la `),ut=r("a"),Ag=t("documentaci\xF3n de AWS NeuronSDK"),Cg=t("."),this.h()},l(e){const i=Tb('[data-svelte="svelte-1phssyn"]',document.head);m=n(i,"META",{name:!0,content:!0}),i.forEach(o),q=p(e),_=n(e,"H1",{class:!0});var mt=l(_);j=n(mt,"A",{id:!0,class:!0,href:!0});var zl=l(j);k=n(zl,"SPAN",{});var Sl=l(k);E(w.$$.fragment,Sl),Sl.forEach(o),zl.forEach(o),A=p(mt),N=n(mt,"SPAN",{});var Ll=l(N);P=s(Ll,"Exportar modelos \u{1F917} Transformers"),Ll.forEach(o),mt.forEach(o),C=p(e),S=n(e,"P",{});var Ml=l(S);O=s(Ml,`Si necesitas implementar modelos \u{1F917} Transformers en entornos de producci\xF3n, te
recomendamos exportarlos a un formato serializado que se pueda cargar y ejecutar
en tiempos de ejecuci\xF3n y hardware especializados. En esta gu\xEDa, te mostraremos c\xF3mo
exportar modelos \u{1F917} Transformers en dos formatos ampliamente utilizados: ONNX y TorchScript.`),Ml.forEach(o),D=p(e),v=n(e,"P",{});var He=l(v);T=s(He,`Una vez exportado, un modelo puede optimizarse para la inferencia a trav\xE9s de t\xE9cnicas
como la cuantizaci\xF3n y `),B=n(He,"EM",{});var Il=l(B);G=s(Il,"pruning"),Il.forEach(o),$e=s(He,`. Si est\xE1s interesado en optimizar tus modelos para
que funcionen con la m\xE1xima eficiencia, consulta la
`),re=n(He,"A",{href:!0,rel:!0});var Lg=l(re);Ha=s(Lg,"biblioteca de \u{1F917} Optimum"),Lg.forEach(o),be=s(He,"."),He.forEach(o),We=p(e),J=n(e,"H2",{class:!0});var Yd=l(J);U=n(Yd,"A",{id:!0,class:!0,href:!0});var Mg=l(U);L=n(Mg,"SPAN",{});var Ig=l(L);E(ne.$$.fragment,Ig),Ig.forEach(o),Mg.forEach(o),ft=p(Yd),Ve=n(Yd,"SPAN",{});var Bg=l(Ve);ht=s(Bg,"ONNX"),Bg.forEach(o),Yd.forEach(o),Ua=p(e),H=n(e,"P",{});var Ma=l(H);_t=s(Ma,"El proyecto "),Wa=n(Ma,"A",{href:!0,rel:!0});var Xg=l(Wa);Kc=s(Xg,"ONNX (Open Neural Network eXchange)"),Xg.forEach(o),Gc=s(Ma,` es un
est\xE1ndar abierto que define un conjunto com\xFAn de operadores y un formato
de archivo com\xFAn para representar modelos de aprendizaje profundo en una
amplia variedad de `),is=n(Ma,"EM",{});var Rg=l(is);Jc=s(Rg,"frameworks"),Rg.forEach(o),Yc=s(Ma,`, incluidos PyTorch y TensorFlow. Cuando un modelo
se exporta al formato ONNX, estos operadores se usan para construir un
grafo computacional (a menudo llamado `),ds=n(Ma,"EM",{});var Fg=l(ds);Qc=s(Fg,"representaci\xF3n intermedia"),Fg.forEach(o),Zc=s(Ma,`) que
representa el flujo de datos a trav\xE9s de la red neuronal.`),Ma.forEach(o),Fl=p(e),vt=n(e,"P",{});var Hg=l(vt);ep=s(Hg,`Al exponer un grafo con operadores y tipos de datos estandarizados, ONNX facilita
el cambio entre frameworks. Por ejemplo, un modelo entrenado en PyTorch se puede
exportar a formato ONNX y luego importar en TensorFlow (y viceversa).`),Hg.forEach(o),Hl=p(e),Ke=n(e,"P",{});var Qd=l(Ke);ap=s(Qd,"\u{1F917} Transformers proporciona un paquete llamado "),cs=n(Qd,"CODE",{});var Ug=l(cs);op=s(Ug,"transformers.onnx"),Ug.forEach(o),tp=s(Qd,`, el cual permite convertir
los checkpoints de un modelo en un grafo ONNX aprovechando los objetos de configuraci\xF3n.
Estos objetos de configuraci\xF3n est\xE1n hechos a la medida de diferentes arquitecturas de modelos
y est\xE1n dise\xF1ados para ser f\xE1cilmente extensibles a otras arquitecturas.`),Qd.forEach(o),Ul=p(e),gt=n(e,"P",{});var Wg=l(gt);sp=s(Wg,"Las configuraciones a la medida incluyen las siguientes arquitecturas:"),Wg.forEach(o),Wl=p(e),f=n(e,"UL",{});var h=l(f);ps=n(h,"LI",{});var Vg=l(ps);rp=s(Vg,"ALBERT"),Vg.forEach(o),np=p(h),us=n(h,"LI",{});var Kg=l(us);lp=s(Kg,"BART"),Kg.forEach(o),ip=p(h),ms=n(h,"LI",{});var Gg=l(ms);dp=s(Gg,"BEiT"),Gg.forEach(o),cp=p(h),fs=n(h,"LI",{});var Jg=l(fs);pp=s(Jg,"BERT"),Jg.forEach(o),up=p(h),hs=n(h,"LI",{});var Yg=l(hs);mp=s(Yg,"BigBird"),Yg.forEach(o),fp=p(h),_s=n(h,"LI",{});var Qg=l(_s);hp=s(Qg,"BigBird-Pegasus"),Qg.forEach(o),_p=p(h),vs=n(h,"LI",{});var Zg=l(vs);vp=s(Zg,"Blenderbot"),Zg.forEach(o),gp=p(h),gs=n(h,"LI",{});var eE=l(gs);Ep=s(eE,"BlenderbotSmall"),eE.forEach(o),$p=p(h),Es=n(h,"LI",{});var aE=l(Es);bp=s(aE,"BLOOM"),aE.forEach(o),xp=p(h),$s=n(h,"LI",{});var oE=l($s);yp=s(oE,"CamemBERT"),oE.forEach(o),jp=p(h),bs=n(h,"LI",{});var tE=l(bs);qp=s(tE,"CLIP"),tE.forEach(o),wp=p(h),xs=n(h,"LI",{});var sE=l(xs);kp=s(sE,"CodeGen"),sE.forEach(o),Tp=p(h),ys=n(h,"LI",{});var rE=l(ys);Op=s(rE,"ConvBERT"),rE.forEach(o),Np=p(h),js=n(h,"LI",{});var nE=l(js);Pp=s(nE,"ConvNeXT"),nE.forEach(o),Ap=p(h),qs=n(h,"LI",{});var lE=l(qs);Cp=s(lE,"Data2VecText"),lE.forEach(o),Dp=p(h),ws=n(h,"LI",{});var iE=l(ws);zp=s(iE,"Data2VecVision"),iE.forEach(o),Sp=p(h),ks=n(h,"LI",{});var dE=l(ks);Lp=s(dE,"DeBERTa"),dE.forEach(o),Mp=p(h),Ts=n(h,"LI",{});var cE=l(Ts);Ip=s(cE,"DeBERTa-v2"),cE.forEach(o),Bp=p(h),Os=n(h,"LI",{});var pE=l(Os);Xp=s(pE,"DeiT"),pE.forEach(o),Rp=p(h),Ns=n(h,"LI",{});var uE=l(Ns);Fp=s(uE,"DETR"),uE.forEach(o),Hp=p(h),Ps=n(h,"LI",{});var mE=l(Ps);Up=s(mE,"DistilBERT"),mE.forEach(o),Wp=p(h),As=n(h,"LI",{});var fE=l(As);Vp=s(fE,"ELECTRA"),fE.forEach(o),Kp=p(h),Cs=n(h,"LI",{});var hE=l(Cs);Gp=s(hE,"FlauBERT"),hE.forEach(o),Jp=p(h),Ds=n(h,"LI",{});var _E=l(Ds);Yp=s(_E,"GPT Neo"),_E.forEach(o),Qp=p(h),zs=n(h,"LI",{});var vE=l(zs);Zp=s(vE,"GPT-J"),vE.forEach(o),eu=p(h),Ss=n(h,"LI",{});var gE=l(Ss);au=s(gE,"I-BERT"),gE.forEach(o),ou=p(h),Ls=n(h,"LI",{});var EE=l(Ls);tu=s(EE,"LayoutLM"),EE.forEach(o),su=p(h),Ms=n(h,"LI",{});var $E=l(Ms);ru=s($E,"LayoutLMv3"),$E.forEach(o),nu=p(h),Is=n(h,"LI",{});var bE=l(Is);lu=s(bE,"LeViT"),bE.forEach(o),iu=p(h),Bs=n(h,"LI",{});var xE=l(Bs);du=s(xE,"LongT5"),xE.forEach(o),cu=p(h),Xs=n(h,"LI",{});var yE=l(Xs);pu=s(yE,"M2M100"),yE.forEach(o),uu=p(h),Rs=n(h,"LI",{});var jE=l(Rs);mu=s(jE,"Marian"),jE.forEach(o),fu=p(h),Fs=n(h,"LI",{});var qE=l(Fs);hu=s(qE,"mBART"),qE.forEach(o),_u=p(h),Hs=n(h,"LI",{});var wE=l(Hs);vu=s(wE,"MobileBERT"),wE.forEach(o),gu=p(h),Us=n(h,"LI",{});var kE=l(Us);Eu=s(kE,"MobileViT"),kE.forEach(o),$u=p(h),Ws=n(h,"LI",{});var TE=l(Ws);bu=s(TE,"MT5"),TE.forEach(o),xu=p(h),Vs=n(h,"LI",{});var OE=l(Vs);yu=s(OE,"OpenAI GPT-2"),OE.forEach(o),ju=p(h),Ks=n(h,"LI",{});var NE=l(Ks);qu=s(NE,"Perceiver"),NE.forEach(o),wu=p(h),Gs=n(h,"LI",{});var PE=l(Gs);ku=s(PE,"PLBart"),PE.forEach(o),Tu=p(h),Js=n(h,"LI",{});var AE=l(Js);Ou=s(AE,"ResNet"),AE.forEach(o),Nu=p(h),Ys=n(h,"LI",{});var CE=l(Ys);Pu=s(CE,"RoBERTa"),CE.forEach(o),Au=p(h),Qs=n(h,"LI",{});var DE=l(Qs);Cu=s(DE,"RoFormer"),DE.forEach(o),Du=p(h),Zs=n(h,"LI",{});var zE=l(Zs);zu=s(zE,"SqueezeBERT"),zE.forEach(o),Su=p(h),er=n(h,"LI",{});var SE=l(er);Lu=s(SE,"T5"),SE.forEach(o),Mu=p(h),ar=n(h,"LI",{});var LE=l(ar);Iu=s(LE,"ViT"),LE.forEach(o),Bu=p(h),or=n(h,"LI",{});var ME=l(or);Xu=s(ME,"XLM"),ME.forEach(o),Ru=p(h),tr=n(h,"LI",{});var IE=l(tr);Fu=s(IE,"XLM-RoBERTa"),IE.forEach(o),Hu=p(h),sr=n(h,"LI",{});var BE=l(sr);Uu=s(BE,"XLM-RoBERTa-XL"),BE.forEach(o),Wu=p(h),rr=n(h,"LI",{});var XE=l(rr);Vu=s(XE,"YOLOS"),XE.forEach(o),h.forEach(o),Vl=p(e),Et=n(e,"P",{});var RE=l(Et);Ku=s(RE,"En las pr\xF3ximas dos secciones, te mostraremos c\xF3mo:"),RE.forEach(o),Kl=p(e),Ge=n(e,"UL",{});var Zd=l(Ge);Va=n(Zd,"LI",{});var ec=l(Va);Gu=s(ec,"Exportar un modelo compatible utilizando el paquete "),nr=n(ec,"CODE",{});var FE=l(nr);Ju=s(FE,"transformers.onnx"),FE.forEach(o),Yu=s(ec,"."),ec.forEach(o),Qu=p(Zd),lr=n(Zd,"LI",{});var HE=l(lr);Zu=s(HE,"Exportar un modelo personalizado para una arquitectura no compatible."),HE.forEach(o),Zd.forEach(o),Gl=p(e),xe=n(e,"H3",{class:!0});var ac=l(xe);Je=n(ac,"A",{id:!0,class:!0,href:!0});var UE=l(Je);ir=n(UE,"SPAN",{});var WE=l(ir);E(Ka.$$.fragment,WE),WE.forEach(o),UE.forEach(o),em=p(ac),dr=n(ac,"SPAN",{});var VE=l(dr);am=s(VE,"Exportar un model a ONNX"),VE.forEach(o),ac.forEach(o),Jl=p(e),$t=n(e,"P",{});var KE=l($t);om=s(KE,`Para exportar un modelo \u{1F917} Transformers a ONNX, tienes que instalar primero algunas
dependencias extra:`),KE.forEach(o),Yl=p(e),E(Ga.$$.fragment,e),Ql=p(e),Ye=n(e,"P",{});var oc=l(Ye);tm=s(oc,"El paquete "),cr=n(oc,"CODE",{});var GE=l(cr);sm=s(GE,"transformers.onnx"),GE.forEach(o),rm=s(oc," puede ser usado luego como un m\xF3dulo de Python:"),oc.forEach(o),Zl=p(e),E(Ja.$$.fragment,e),ei=p(e),bt=n(e,"P",{});var JE=l(bt);nm=s(JE,"Exportar un checkpoint usando una configuraci\xF3n a la medida se puede hacer de la siguiente manera:"),JE.forEach(o),ai=p(e),E(Ya.$$.fragment,e),oi=p(e),xt=n(e,"P",{});var YE=l(xt);lm=s(YE,"que deber\xEDa mostrar los siguientes registros:"),YE.forEach(o),ti=p(e),E(Qa.$$.fragment,e),si=p(e),le=n(e,"P",{});var Kt=l(le);im=s(Kt,"Esto exporta un grafo ONNX del checkpoint definido por el argumento "),pr=n(Kt,"CODE",{});var QE=l(pr);dm=s(QE,"--model"),QE.forEach(o),cm=s(Kt,`.
En este ejemplo, es un modelo `),ur=n(Kt,"CODE",{});var ZE=l(ur);pm=s(ZE,"distilbert-base-uncased"),ZE.forEach(o),um=s(Kt,`, pero puede ser cualquier
checkpoint en Hugging Face Hub o que est\xE9 almacenado localmente.`),Kt.forEach(o),ri=p(e),Q=n(e,"P",{});var Ia=l(Q);mm=s(Ia,"El archivo "),mr=n(Ia,"CODE",{});var e1=l(mr);fm=s(e1,"model.onnx"),e1.forEach(o),hm=s(Ia,` resultante se puede ejecutar en uno de los
`),Za=n(Ia,"A",{href:!0,rel:!0});var a1=l(Za);_m=s(a1,"muchos aceleradores"),a1.forEach(o),vm=s(Ia,`
que admiten el est\xE1ndar ONNX. Por ejemplo, podemos cargar y ejecutar el
modelo con `),eo=n(Ia,"A",{href:!0,rel:!0});var o1=l(eo);gm=s(o1,"ONNX Runtime"),o1.forEach(o),Em=s(Ia," de la siguiente manera:"),Ia.forEach(o),ni=p(e),E(ao.$$.fragment,e),li=p(e),Qe=n(e,"P",{});var tc=l(Qe);$m=s(tc,"Los nombres necesarios de salida (es decir, "),fr=n(tc,"CODE",{});var t1=l(fr);bm=s(t1,'["last_hidden_state"]'),t1.forEach(o),xm=s(tc,`) se pueden obtener
echando un vistazo a la configuraci\xF3n ONNX de cada modelo. Por ejemplo, para DistilBERT tenemos:`),tc.forEach(o),ii=p(e),E(oo.$$.fragment,e),di=p(e),Ze=n(e,"P",{});var sc=l(Ze);ym=s(sc,`El proceso es id\xE9ntico para los checkpoints de TensorFlow en Hub.
Por ejemplo, podemos exportar un checkpoint puro de TensorFlow desde
`),to=n(sc,"A",{href:!0,rel:!0});var s1=l(to);jm=s(s1,"Keras"),s1.forEach(o),qm=s(sc," de la siguiente manera:"),sc.forEach(o),ci=p(e),E(so.$$.fragment,e),pi=p(e),yt=n(e,"P",{});var r1=l(yt);wm=s(r1,`Para exportar un modelo que est\xE1 almacenado localmente, deber\xE1s tener los pesos
y tokenizadores del modelo almacenados en un directorio. Por ejemplo, podemos cargar
y guardar un checkpoint de la siguiente manera:`),r1.forEach(o),ui=p(e),E(ea.$$.fragment,e),mi=p(e),ye=n(e,"H3",{class:!0});var rc=l(ye);aa=n(rc,"A",{id:!0,class:!0,href:!0});var n1=l(aa);hr=n(n1,"SPAN",{});var l1=l(hr);E(ro.$$.fragment,l1),l1.forEach(o),n1.forEach(o),km=p(rc),_r=n(rc,"SPAN",{});var i1=l(_r);Tm=s(i1,"Seleccionar caracter\xEDsticas para diferentes topolog\xEDas de un modelo"),i1.forEach(o),rc.forEach(o),fi=p(e),oa=n(e,"P",{});var nc=l(oa);Om=s(nc,"Cada configuraci\xF3n a la medida viene con un conjunto de "),vr=n(nc,"EM",{});var d1=l(vr);Nm=s(d1,"caracter\xEDsticas"),d1.forEach(o),Pm=s(nc,` que te permiten exportar
modelos para diferentes tipos de topolog\xEDas o tareas. Como se muestra en la siguiente tabla, cada
funci\xF3n est\xE1 asociada con una auto-clase de autom\xF3vil diferente:`),nc.forEach(o),hi=p(e),ta=n(e,"TABLE",{});var lc=l(ta);gr=n(lc,"THEAD",{});var c1=l(gr);no=n(c1,"TR",{});var ic=l(no);Er=n(ic,"TH",{});var p1=l(Er);Am=s(p1,"Feature"),p1.forEach(o),Cm=p(ic),$r=n(ic,"TH",{});var u1=l($r);Dm=s(u1,"Auto Class"),u1.forEach(o),ic.forEach(o),c1.forEach(o),zm=p(lc),X=n(lc,"TBODY",{});var K=l(X);lo=n(K,"TR",{});var dc=l(lo);io=n(dc,"TD",{});var cc=l(io);br=n(cc,"CODE",{});var m1=l(br);Sm=s(m1,"causal-lm"),m1.forEach(o),Lm=s(cc,", "),xr=n(cc,"CODE",{});var f1=l(xr);Mm=s(f1,"causal-lm-with-past"),f1.forEach(o),cc.forEach(o),Im=p(dc),yr=n(dc,"TD",{});var h1=l(yr);jr=n(h1,"CODE",{});var _1=l(jr);Bm=s(_1,"AutoModelForCausalLM"),_1.forEach(o),h1.forEach(o),dc.forEach(o),Xm=p(K),co=n(K,"TR",{});var pc=l(co);po=n(pc,"TD",{});var uc=l(po);qr=n(uc,"CODE",{});var v1=l(qr);Rm=s(v1,"default"),v1.forEach(o),Fm=s(uc,", "),wr=n(uc,"CODE",{});var g1=l(wr);Hm=s(g1,"default-with-past"),g1.forEach(o),uc.forEach(o),Um=p(pc),kr=n(pc,"TD",{});var E1=l(kr);Tr=n(E1,"CODE",{});var $1=l(Tr);Wm=s($1,"AutoModel"),$1.forEach(o),E1.forEach(o),pc.forEach(o),Vm=p(K),uo=n(K,"TR",{});var mc=l(uo);Or=n(mc,"TD",{});var b1=l(Or);Nr=n(b1,"CODE",{});var x1=l(Nr);Km=s(x1,"masked-lm"),x1.forEach(o),b1.forEach(o),Gm=p(mc),Pr=n(mc,"TD",{});var y1=l(Pr);Ar=n(y1,"CODE",{});var j1=l(Ar);Jm=s(j1,"AutoModelForMaskedLM"),j1.forEach(o),y1.forEach(o),mc.forEach(o),Ym=p(K),mo=n(K,"TR",{});var fc=l(mo);Cr=n(fc,"TD",{});var q1=l(Cr);Dr=n(q1,"CODE",{});var w1=l(Dr);Qm=s(w1,"question-answering"),w1.forEach(o),q1.forEach(o),Zm=p(fc),zr=n(fc,"TD",{});var k1=l(zr);Sr=n(k1,"CODE",{});var T1=l(Sr);ef=s(T1,"AutoModelForQuestionAnswering"),T1.forEach(o),k1.forEach(o),fc.forEach(o),af=p(K),fo=n(K,"TR",{});var hc=l(fo);ho=n(hc,"TD",{});var _c=l(ho);Lr=n(_c,"CODE",{});var O1=l(Lr);of=s(O1,"seq2seq-lm"),O1.forEach(o),tf=s(_c,", "),Mr=n(_c,"CODE",{});var N1=l(Mr);sf=s(N1,"seq2seq-lm-with-past"),N1.forEach(o),_c.forEach(o),rf=p(hc),Ir=n(hc,"TD",{});var P1=l(Ir);Br=n(P1,"CODE",{});var A1=l(Br);nf=s(A1,"AutoModelForSeq2SeqLM"),A1.forEach(o),P1.forEach(o),hc.forEach(o),lf=p(K),_o=n(K,"TR",{});var vc=l(_o);Xr=n(vc,"TD",{});var C1=l(Xr);Rr=n(C1,"CODE",{});var D1=l(Rr);df=s(D1,"sequence-classification"),D1.forEach(o),C1.forEach(o),cf=p(vc),Fr=n(vc,"TD",{});var z1=l(Fr);Hr=n(z1,"CODE",{});var S1=l(Hr);pf=s(S1,"AutoModelForSequenceClassification"),S1.forEach(o),z1.forEach(o),vc.forEach(o),uf=p(K),vo=n(K,"TR",{});var gc=l(vo);Ur=n(gc,"TD",{});var L1=l(Ur);Wr=n(L1,"CODE",{});var M1=l(Wr);mf=s(M1,"token-classification"),M1.forEach(o),L1.forEach(o),ff=p(gc),Vr=n(gc,"TD",{});var I1=l(Vr);Kr=n(I1,"CODE",{});var B1=l(Kr);hf=s(B1,"AutoModelForTokenClassification"),B1.forEach(o),I1.forEach(o),gc.forEach(o),K.forEach(o),lc.forEach(o),_i=p(e),sa=n(e,"P",{});var Ec=l(sa);_f=s(Ec,"Para cada configuraci\xF3n, puedes encontrar la lista de funciones admitidas a trav\xE9s de "),Gr=n(Ec,"CODE",{});var X1=l(Gr);vf=s(X1,"FeaturesManager"),X1.forEach(o),gf=s(Ec,`.
Por ejemplo, para DistilBERT tenemos:`),Ec.forEach(o),vi=p(e),E(go.$$.fragment,e),gi=p(e),ie=n(e,"P",{});var Gt=l(ie);Ef=s(Gt,"Le puedes pasar una de estas caracter\xEDsticas al argumento "),Jr=n(Gt,"CODE",{});var R1=l(Jr);$f=s(R1,"--feature"),R1.forEach(o),bf=s(Gt," en el paquete "),Yr=n(Gt,"CODE",{});var F1=l(Yr);xf=s(F1,"transformers.onnx"),F1.forEach(o),yf=s(Gt,`.
Por ejemplo, para exportar un modelo de clasificaci\xF3n de texto, podemos elegir un modelo ya ajustado del Hub y ejecutar:`),Gt.forEach(o),Ei=p(e),E(Eo.$$.fragment,e),$i=p(e),jt=n(e,"P",{});var H1=l(jt);jf=s(H1,"que mostrar\xE1 los siguientes registros:"),H1.forEach(o),bi=p(e),E($o.$$.fragment,e),xi=p(e),Z=n(e,"P",{});var Ba=l(Z);qf=s(Ba,"Ten en cuenta que, en este caso, los nombres de salida del modelo ajustado son "),Qr=n(Ba,"CODE",{});var U1=l(Qr);wf=s(U1,"logits"),U1.forEach(o),kf=s(Ba," en lugar de "),Zr=n(Ba,"CODE",{});var W1=l(Zr);Tf=s(W1,"last_hidden_state"),W1.forEach(o),Of=s(Ba,`
que vimos anteriormente con el checkpoint `),en=n(Ba,"CODE",{});var V1=l(en);Nf=s(V1,"distilbert-base-uncased"),V1.forEach(o),Pf=s(Ba,`. Esto es de esperarse ya que el modelo ajustado
tiene un cabezal de clasificaci\xF3n secuencial.`),Ba.forEach(o),yi=p(e),E(ra.$$.fragment,e),ji=p(e),je=n(e,"H3",{class:!0});var $c=l(je);na=n($c,"A",{id:!0,class:!0,href:!0});var K1=l(na);an=n(K1,"SPAN",{});var G1=l(an);E(bo.$$.fragment,G1),G1.forEach(o),K1.forEach(o),Af=p($c),on=n($c,"SPAN",{});var J1=l(on);Cf=s(J1,"Exportar un modelo para una arquitectura no compatible"),J1.forEach(o),$c.forEach(o),qi=p(e),qt=n(e,"P",{});var Y1=l(qt);Df=s(Y1,`Si deseas exportar un modelo cuya arquitectura no es compatible de forma nativa
con la biblioteca, debes seguir tres pasos principales:`),Y1.forEach(o),wi=p(e),de=n(e,"OL",{});var Jt=l(de);tn=n(Jt,"LI",{});var Q1=l(tn);zf=s(Q1,"Implementa una configuraci\xF3n personalizada en ONNX."),Q1.forEach(o),Sf=p(Jt),sn=n(Jt,"LI",{});var Z1=l(sn);Lf=s(Z1,"Exporta el modelo a ONNX."),Z1.forEach(o),Mf=p(Jt),rn=n(Jt,"LI",{});var e$=l(rn);If=s(e$,"Valide los resultados de PyTorch y los modelos exportados."),e$.forEach(o),Jt.forEach(o),ki=p(e),wt=n(e,"P",{});var a$=l(wt);Bf=s(a$,`En esta secci\xF3n, veremos c\xF3mo se implement\xF3 la serializaci\xF3n de DistilBERT
para mostrar lo que implica cada paso.`),a$.forEach(o),Ti=p(e),qe=n(e,"H4",{class:!0});var bc=l(qe);la=n(bc,"A",{id:!0,class:!0,href:!0});var o$=l(la);nn=n(o$,"SPAN",{});var t$=l(nn);E(xo.$$.fragment,t$),t$.forEach(o),o$.forEach(o),Xf=p(bc),ln=n(bc,"SPAN",{});var s$=l(ln);Rf=s(s$,"Implementar una configuraci\xF3n personalizada en ONNX"),s$.forEach(o),bc.forEach(o),Oi=p(e),kt=n(e,"P",{});var r$=l(kt);Ff=s(r$,`Comencemos con el objeto de configuraci\xF3n de ONNX. Proporcionamos tres clases abstractas
de las que debe heredar, seg\xFAn el tipo de arquitectura del modelo que quieras exportar:`),r$.forEach(o),Ni=p(e),ce=n(e,"UL",{});var Yt=l(ce);ia=n(Yt,"LI",{});var Bl=l(ia);Hf=s(Bl,"Modelos basados en el "),dn=n(Bl,"EM",{});var n$=l(dn);Uf=s(n$,"Encoder"),n$.forEach(o),Wf=s(Bl," inherente de "),cn=n(Bl,"CODE",{});var l$=l(cn);Vf=s(l$,"OnnxConfig"),l$.forEach(o),Bl.forEach(o),Kf=p(Yt),da=n(Yt,"LI",{});var Xl=l(da);Gf=s(Xl,"Modelos basados en el "),pn=n(Xl,"EM",{});var i$=l(pn);Jf=s(i$,"Decoder"),i$.forEach(o),Yf=s(Xl," inherente de "),un=n(Xl,"CODE",{});var d$=l(un);Qf=s(d$,"OnnxConfigWithPast"),d$.forEach(o),Xl.forEach(o),Zf=p(Yt),ca=n(Yt,"LI",{});var Rl=l(ca);eh=s(Rl,"Modelos "),mn=n(Rl,"EM",{});var c$=l(mn);ah=s(c$,"Encoder-decoder"),c$.forEach(o),oh=s(Rl," inherente de "),fn=n(Rl,"CODE",{});var p$=l(fn);th=s(p$,"OnnxSeq2SeqConfigWithPast"),p$.forEach(o),Rl.forEach(o),Yt.forEach(o),Pi=p(e),E(pa.$$.fragment,e),Ai=p(e),pe=n(e,"P",{});var Qt=l(pe);sh=s(Qt,"Dado que DistilBERT es un modelo de tipo "),hn=n(Qt,"EM",{});var u$=l(hn);rh=s(u$,"encoder"),u$.forEach(o),nh=s(Qt,", su configuraci\xF3n se hereda de "),_n=n(Qt,"CODE",{});var m$=l(_n);lh=s(m$,"OnnxConfig"),m$.forEach(o),ih=s(Qt,":"),Qt.forEach(o),Ci=p(e),E(yo.$$.fragment,e),Di=p(e),W=n(e,"P",{});var ge=l(W);dh=s(ge,"Cada objeto de configuraci\xF3n debe implementar la propiedad "),vn=n(ge,"CODE",{});var f$=l(vn);ch=s(f$,"inputs"),f$.forEach(o),ph=s(ge,` y devolver un mapeo,
donde cada llave corresponde a una entrada esperada y cada valor indica el eje de esa entrada.
Para DistilBERT, podemos ver que se requieren dos entradas: `),gn=n(ge,"CODE",{});var h$=l(gn);uh=s(h$,"input_ids"),h$.forEach(o),mh=s(ge," y "),En=n(ge,"CODE",{});var _$=l(En);fh=s(_$,"attention_mask"),_$.forEach(o),hh=s(ge,`.
Estas entradas tienen la misma forma de `),$n=n(ge,"CODE",{});var v$=l($n);_h=s(v$,"(batch_size, sequence_length)"),v$.forEach(o),vh=s(ge,`, es por lo que vemos
los mismos ejes utilizados en la configuraci\xF3n.`),ge.forEach(o),zi=p(e),E(ua.$$.fragment,e),Si=p(e),Tt=n(e,"P",{});var g$=l(Tt);gh=s(g$,`Una vez que hayas implementado una configuraci\xF3n ONNX, puedes crear una
instancia proporcionando la configuraci\xF3n del modelo base de la siguiente manera:`),g$.forEach(o),Li=p(e),E(jo.$$.fragment,e),Mi=p(e),Ot=n(e,"P",{});var E$=l(Ot);Eh=s(E$,`El objeto resultante tiene varias propiedades \xFAtiles. Por ejemplo, puedes ver el conjunto de operadores ONNX que se
utilizar\xE1 durante la exportaci\xF3n:`),E$.forEach(o),Ii=p(e),E(qo.$$.fragment,e),Bi=p(e),Nt=n(e,"P",{});var $$=l(Nt);$h=s($$,"Tambi\xE9n puedes ver los resultados asociados con el modelo de la siguiente manera:"),$$.forEach(o),Xi=p(e),E(wo.$$.fragment,e),Ri=p(e),V=n(e,"P",{});var Ee=l(V);bh=s(Ee,`Observa que la propiedad de salidas sigue la misma estructura que las entradas;
devuelve un objecto `),bn=n(Ee,"CODE",{});var b$=l(bn);xh=s(b$,"OrderedDict"),b$.forEach(o),yh=s(Ee,` de salidas nombradas y sus formas. La estructura
de salida est\xE1 vinculada a la elecci\xF3n de la funci\xF3n con la que se inicializa la configuraci\xF3n.
Por defecto, la configuraci\xF3n de ONNX se inicializa con la funci\xF3n `),xn=n(Ee,"CODE",{});var x$=l(xn);jh=s(x$,"default"),x$.forEach(o),qh=s(Ee,` que
corresponde a exportar un modelo cargado con la clase `),yn=n(Ee,"CODE",{});var y$=l(yn);wh=s(y$,"AutoModel"),y$.forEach(o),kh=s(Ee,`. Si quieres exportar
una topolog\xEDa de modelo diferente, simplemente proporciona una caracter\xEDstica diferente
al argumento `),jn=n(Ee,"CODE",{});var j$=l(jn);Th=s(j$,"task"),j$.forEach(o),Oh=s(Ee,` cuando inicialices la configuraci\xF3n de ONNX. Por ejemplo, si quisi\xE9ramos
exportar DistilBERT con un cabezal de clasificaci\xF3n de secuencias, podr\xEDamos usar:`),Ee.forEach(o),Fi=p(e),E(ko.$$.fragment,e),Hi=p(e),E(ma.$$.fragment,e),Ui=p(e),we=n(e,"H4",{class:!0});var xc=l(we);fa=n(xc,"A",{id:!0,class:!0,href:!0});var q$=l(fa);qn=n(q$,"SPAN",{});var w$=l(qn);E(To.$$.fragment,w$),w$.forEach(o),q$.forEach(o),Nh=p(xc),wn=n(xc,"SPAN",{});var k$=l(wn);Ph=s(k$,"Exportar el modelo"),k$.forEach(o),xc.forEach(o),Wi=p(e),ue=n(e,"P",{});var Zt=l(ue);Ah=s(Zt,`Una vez que hayas implementado la configuraci\xF3n de ONNX, el siguiente paso es exportar el modelo.
Aqu\xED podemos usar la funci\xF3n `),kn=n(Zt,"CODE",{});var T$=l(kn);Ch=s(T$,"export()"),T$.forEach(o),Dh=s(Zt," proporcionada por el paquete "),Tn=n(Zt,"CODE",{});var O$=l(Tn);zh=s(O$,"transformers.onnx"),O$.forEach(o),Sh=s(Zt,`.
Esta funci\xF3n espera la configuraci\xF3n de ONNX, junto con el modelo base y el tokenizador,
y la ruta para guardar el archivo exportado:`),Zt.forEach(o),Vi=p(e),E(Oo.$$.fragment,e),Ki=p(e),R=n(e,"P",{});var te=l(R);Lh=s(te,"Los objetos "),On=n(te,"CODE",{});var N$=l(On);Mh=s(N$,"onnx_inputs"),N$.forEach(o),Ih=s(te," y "),Nn=n(te,"CODE",{});var P$=l(Nn);Bh=s(P$,"onnx_outputs"),P$.forEach(o),Xh=s(te," devueltos por la funci\xF3n "),Pn=n(te,"CODE",{});var A$=l(Pn);Rh=s(A$,"export()"),A$.forEach(o),Fh=s(te,`
son listas de llaves definidas en las propiedades `),An=n(te,"CODE",{});var C$=l(An);Hh=s(C$,"inputs"),C$.forEach(o),Uh=s(te," y "),Cn=n(te,"CODE",{});var D$=l(Cn);Wh=s(D$,"outputs"),D$.forEach(o),Vh=s(te,` de la configuraci\xF3n.
Una vez exportado el modelo, puedes probar que el modelo est\xE1 bien formado de la siguiente manera:`),te.forEach(o),Gi=p(e),E(No.$$.fragment,e),Ji=p(e),E(ha.$$.fragment,e),Yi=p(e),ke=n(e,"H4",{class:!0});var yc=l(ke);_a=n(yc,"A",{id:!0,class:!0,href:!0});var z$=l(_a);Dn=n(z$,"SPAN",{});var S$=l(Dn);E(Po.$$.fragment,S$),S$.forEach(o),z$.forEach(o),Kh=p(yc),zn=n(yc,"SPAN",{});var L$=l(zn);Gh=s(L$,"Validar los resultados del modelo"),L$.forEach(o),yc.forEach(o),Qi=p(e),me=n(e,"P",{});var es=l(me);Jh=s(es,`El paso final es validar que los resultados del modelo base y exportado coincidan dentro
de cierta tolerancia absoluta. Aqu\xED podemos usar la funci\xF3n `),Sn=n(es,"CODE",{});var M$=l(Sn);Yh=s(M$,"validate_model_outputs()"),M$.forEach(o),Qh=s(es,`
proporcionada por el paquete `),Ln=n(es,"CODE",{});var I$=l(Ln);Zh=s(I$,"transformers.onnx"),I$.forEach(o),e_=s(es," de la siguiente manera:"),es.forEach(o),Zi=p(e),E(Ao.$$.fragment,e),ed=p(e),va=n(e,"P",{});var jc=l(va);a_=s(jc,"Esta funci\xF3n usa el m\xE9todo "),Mn=n(jc,"CODE",{});var B$=l(Mn);o_=s(B$,"OnnxConfig.generate_dummy_inputs()"),B$.forEach(o),t_=s(jc,` para generar entradas para el modelo base
y exportado, y la tolerancia absoluta se puede definir en la configuraci\xF3n. En general, encontramos una
concordancia num\xE9rica en el rango de 1e-6 a 1e-4, aunque es probable que cualquier valor menor que 1e-3 est\xE9 bien.`),jc.forEach(o),ad=p(e),Te=n(e,"H3",{class:!0});var qc=l(Te);ga=n(qc,"A",{id:!0,class:!0,href:!0});var X$=l(ga);In=n(X$,"SPAN",{});var R$=l(In);E(Co.$$.fragment,R$),R$.forEach(o),X$.forEach(o),s_=p(qc),Bn=n(qc,"SPAN",{});var F$=l(Bn);r_=s(F$,"Contribuir con una nueva configuraci\xF3n a \u{1F917} Transformers"),F$.forEach(o),qc.forEach(o),od=p(e),Pt=n(e,"P",{});var H$=l(Pt);n_=s(H$,`\xA1Estamos buscando expandir el conjunto de configuraciones a la medida para usar y agradecemos las contribuciones de la comunidad!
Si deseas contribuir con su colaboraci\xF3n a la biblioteca, deber\xE1s:`),H$.forEach(o),td=p(e),fe=n(e,"UL",{});var as=l(fe);Do=n(as,"LI",{});var wc=l(Do);l_=s(wc,"Implementa la configuraci\xF3n de ONNX en el archivo "),Xn=n(wc,"CODE",{});var U$=l(Xn);i_=s(U$,"configuration_<model_name>.py"),U$.forEach(o),d_=s(wc," correspondiente"),wc.forEach(o),c_=p(as),At=n(as,"LI",{});var Dg=l(At);p_=s(Dg,"Incluye la arquitectura del modelo y las caracter\xEDsticas correspondientes en "),Rn=n(Dg,"CODE",{});var W$=l(Rn);u_=s(W$,"~onnx.features.FeatureManager"),W$.forEach(o),Dg.forEach(o),m_=p(as),Ct=n(as,"LI",{});var zg=l(Ct);f_=s(zg,"Agrega tu arquitectura de modelo a las pruebas en "),Fn=n(zg,"CODE",{});var V$=l(Fn);h_=s(V$,"test_onnx_v2.py"),V$.forEach(o),zg.forEach(o),as.forEach(o),sd=p(e),Ea=n(e,"P",{});var kc=l(Ea);__=s(kc,"Revisa c\xF3mo fue la contribuci\xF3n para la "),zo=n(kc,"A",{href:!0,rel:!0});var K$=l(zo);v_=s(K$,"configuraci\xF3n de IBERT"),K$.forEach(o),g_=s(kc,`
y as\xED tener una idea de lo que necesito.`),kc.forEach(o),rd=p(e),Oe=n(e,"H2",{class:!0});var Tc=l(Oe);$a=n(Tc,"A",{id:!0,class:!0,href:!0});var G$=l($a);Hn=n(G$,"SPAN",{});var J$=l(Hn);E(So.$$.fragment,J$),J$.forEach(o),G$.forEach(o),E_=p(Tc),Un=n(Tc,"SPAN",{});var Y$=l(Un);$_=s(Y$,"TorchScript"),Y$.forEach(o),Tc.forEach(o),nd=p(e),E(ba.$$.fragment,e),ld=p(e),xa=n(e,"P",{});var Oc=l(xa);b_=s(Oc,`Seg\xFAn la documentaci\xF3n de PyTorch: \u201CTorchScript es una forma de crear modelos serializables y optimizables a partir del
c\xF3digo de PyTorch\u201D. Los dos m\xF3dulos de Pytorch `),Lo=n(Oc,"A",{href:!0,rel:!0});var Q$=l(Lo);x_=s(Q$,"JIT y TRACE"),Q$.forEach(o),y_=s(Oc,` permiten al
desarrollador exportar su modelo para reutilizarlo  en otros programas, como los programas C++ orientados a la eficiencia.`),Oc.forEach(o),id=p(e),Dt=n(e,"P",{});var Z$=l(Dt);j_=s(Z$,`Hemos proporcionado una interfaz que permite exportar modelos de \u{1F917} Transformers a TorchScript para que puedan reutilizarse
en un entorno diferente  al de un programa Python basado en PyTorch. Aqu\xED explicamos c\xF3mo exportar y usar nuestros modelos
usando TorchScript.`),Z$.forEach(o),dd=p(e),zt=n(e,"P",{});var e2=l(zt);q_=s(e2,"Exportar un modelo requiere de dos cosas:"),e2.forEach(o),cd=p(e),ya=n(e,"UL",{});var Nc=l(ya);Wn=n(Nc,"LI",{});var a2=l(Wn);w_=s(a2,"un pase hacia adelante con entradas ficticias."),a2.forEach(o),k_=p(Nc),Mo=n(Nc,"LI",{});var Pc=l(Mo);T_=s(Pc,"instanciaci\xF3n del modelo con la indicador "),Vn=n(Pc,"CODE",{});var o2=l(Vn);O_=s(o2,"torchscript"),o2.forEach(o),N_=s(Pc,"."),Pc.forEach(o),Nc.forEach(o),pd=p(e),St=n(e,"P",{});var t2=l(St);P_=s(t2,"Estas necesidades implican varias cosas con las que los desarrolladores deben tener cuidado. \xC9stas se detallan a continuaci\xF3n."),t2.forEach(o),ud=p(e),Ne=n(e,"H3",{class:!0});var Ac=l(Ne);ja=n(Ac,"A",{id:!0,class:!0,href:!0});var s2=l(ja);Kn=n(s2,"SPAN",{});var r2=l(Kn);E(Io.$$.fragment,r2),r2.forEach(o),s2.forEach(o),A_=p(Ac),Gn=n(Ac,"SPAN",{});var n2=l(Gn);C_=s(n2,"Indicador de TorchScript y pesos atados"),n2.forEach(o),Ac.forEach(o),md=p(e),he=n(e,"P",{});var os=l(he);D_=s(os,`Este indicador es necesario porque la mayor\xEDa de los modelos de lenguaje en este repositorio tienen pesos vinculados entre su capa
de `),Jn=n(os,"CODE",{});var l2=l(Jn);z_=s(l2,"Embedding"),l2.forEach(o),S_=s(os," y su capa de "),Yn=n(os,"CODE",{});var i2=l(Yn);L_=s(i2,"Decoding"),i2.forEach(o),M_=s(os,`. TorchScript no permite la exportaci\xF3n de modelos que tengan pesos atados, por lo que es
necesario desvincular y clonar los pesos previamente.`),os.forEach(o),fd=p(e),ee=n(e,"P",{});var Xa=l(ee);I_=s(Xa,"Esto implica que los modelos instanciados con el indicador "),Qn=n(Xa,"CODE",{});var d2=l(Qn);B_=s(d2,"torchscript"),d2.forEach(o),X_=s(Xa," tienen su capa "),Zn=n(Xa,"CODE",{});var c2=l(Zn);R_=s(c2,"Embedding"),c2.forEach(o),F_=s(Xa," y "),el=n(Xa,"CODE",{});var p2=l(el);H_=s(p2,"Decoding"),p2.forEach(o),U_=s(Xa,` separadas,
lo que significa que no deben entrenarse m\xE1s adelante. El entrenamiento desincronizar\xEDa las dos capas, lo que generar\xEDa
resultados inesperados.`),Xa.forEach(o),hd=p(e),qa=n(e,"P",{});var Cc=l(qa);W_=s(Cc,`Este no es el caso de los modelos que no tienen un cabezal de modelo de lenguaje, ya que no tienen pesos atados.
Estos modelos se pueden exportar de forma segura sin el indicador `),al=n(Cc,"CODE",{});var u2=l(al);V_=s(u2,"torchscript"),u2.forEach(o),K_=s(Cc,"."),Cc.forEach(o),_d=p(e),Pe=n(e,"H3",{class:!0});var Dc=l(Pe);wa=n(Dc,"A",{id:!0,class:!0,href:!0});var m2=l(wa);ol=n(m2,"SPAN",{});var f2=l(ol);E(Bo.$$.fragment,f2),f2.forEach(o),m2.forEach(o),G_=p(Dc),tl=n(Dc,"SPAN",{});var h2=l(tl);J_=s(h2,"Entradas ficticias y longitudes est\xE1ndar"),h2.forEach(o),Dc.forEach(o),vd=p(e),Lt=n(e,"P",{});var _2=l(Lt);Y_=s(_2,`Las entradas ficticias se utilizan para crear un modelo de pase hacia adelante. Mientras los valores de las entradas se
propagan a trav\xE9s de las capas, PyTorch realiza un seguimiento de las diferentes operaciones ejecutadas en cada tensor.
Estas operaciones registradas se utilizan luego para crear el \u201Crastro\u201D del modelo.`),_2.forEach(o),gd=p(e),Mt=n(e,"P",{});var v2=l(Mt);Q_=s(v2,`El rastro se crea en relaci\xF3n con las dimensiones de las entradas. Por lo tanto, est\xE1 limitado por las dimensiones de la
entrada ficticia y no funcionar\xE1 para ninguna otra longitud de secuencia o tama\xF1o de lote. Al intentar con un tama\xF1o diferente,
un error como:`),v2.forEach(o),Ed=p(e),It=n(e,"P",{});var g2=l(It);sl=n(g2,"CODE",{});var E2=l(sl);Z_=s(E2,"The expanded size of the tensor (3) must match the existing size (7) at non-singleton dimension 2"),E2.forEach(o),g2.forEach(o),$d=p(e),ka=n(e,"P",{});var zc=l(ka);ev=s(zc,`aparecer\xE1. Por lo tanto, se recomienda rastrear el modelo con un tama\xF1o de entrada ficticia al menos tan grande como la
entrada m\xE1s  grande que se alimentar\xE1 al modelo durante la inferencia. El `),rl=n(zc,"EM",{});var $2=l(rl);av=s($2,"padding"),$2.forEach(o),ov=s(zc,` se puede realizar para completar los
valores que faltan.  Sin embargo, como el modelo se habr\xE1 rastreado con un tama\xF1o de entrada grande, las dimensiones de
las diferentes matrices tambi\xE9n ser\xE1n grandes, lo que dar\xE1 como resultado m\xE1s c\xE1lculos.`),zc.forEach(o),bd=p(e),Bt=n(e,"P",{});var b2=l(Bt);tv=s(b2,`Se recomienda tener cuidado con el n\xFAmero total de operaciones realizadas en cada entrada y seguir de cerca el rendimiento
al exportar modelos de longitud de secuencia variable.`),b2.forEach(o),xd=p(e),Ae=n(e,"H3",{class:!0});var Sc=l(Ae);Ta=n(Sc,"A",{id:!0,class:!0,href:!0});var x2=l(Ta);nl=n(x2,"SPAN",{});var y2=l(nl);E(Xo.$$.fragment,y2),y2.forEach(o),x2.forEach(o),sv=p(Sc),ll=n(Sc,"SPAN",{});var j2=l(ll);rv=s(j2,"Usar TorchScript en Python"),j2.forEach(o),Sc.forEach(o),yd=p(e),Xt=n(e,"P",{});var q2=l(Xt);nv=s(q2,"A continuaci\xF3n se muestra un ejemplo que muestra c\xF3mo guardar, cargar modelos y c\xF3mo usar el rastreo para la inferencia."),q2.forEach(o),jd=p(e),Ce=n(e,"H4",{class:!0});var Lc=l(Ce);Oa=n(Lc,"A",{id:!0,class:!0,href:!0});var w2=l(Oa);il=n(w2,"SPAN",{});var k2=l(il);E(Ro.$$.fragment,k2),k2.forEach(o),w2.forEach(o),lv=p(Lc),dl=n(Lc,"SPAN",{});var T2=l(dl);iv=s(T2,"Guardando un modelo"),T2.forEach(o),Lc.forEach(o),qd=p(e),Y=n(e,"P",{});var Ue=l(Y);dv=s(Ue,"Este fragmento muestra c\xF3mo usar TorchScript para exportar un "),cl=n(Ue,"CODE",{});var O2=l(cl);cv=s(O2,"BertModel"),O2.forEach(o),pv=s(Ue,". Aqu\xED, el "),pl=n(Ue,"CODE",{});var N2=l(pl);uv=s(N2,"BertModel"),N2.forEach(o),mv=s(Ue,` se instancia de acuerdo
con la clase `),ul=n(Ue,"CODE",{});var P2=l(ul);fv=s(P2,"BertConfig"),P2.forEach(o),hv=s(Ue," y luego se guarda en el disco con el nombre de archivo "),ml=n(Ue,"CODE",{});var A2=l(ml);_v=s(A2,"traced_bert.pt"),A2.forEach(o),Ue.forEach(o),wd=p(e),E(Fo.$$.fragment,e),kd=p(e),De=n(e,"H4",{class:!0});var Mc=l(De);Na=n(Mc,"A",{id:!0,class:!0,href:!0});var C2=l(Na);fl=n(C2,"SPAN",{});var D2=l(fl);E(Ho.$$.fragment,D2),D2.forEach(o),C2.forEach(o),vv=p(Mc),hl=n(Mc,"SPAN",{});var z2=l(hl);gv=s(z2,"Cargar un modelo"),z2.forEach(o),Mc.forEach(o),Td=p(e),ae=n(e,"P",{});var Ra=l(ae);Ev=s(Ra,"Este fragmento muestra c\xF3mo cargar el "),_l=n(Ra,"CODE",{});var S2=l(_l);$v=s(S2,"BertModel"),S2.forEach(o),bv=s(Ra," que se guard\xF3 previamente en el disco con el nombre "),vl=n(Ra,"CODE",{});var L2=l(vl);xv=s(L2,"traced_bert.pt"),L2.forEach(o),yv=s(Ra,`.
Estamos reutilizando el `),gl=n(Ra,"CODE",{});var M2=l(gl);jv=s(M2,"dummy_input"),M2.forEach(o),qv=s(Ra," previamente inicializado."),Ra.forEach(o),Od=p(e),E(Uo.$$.fragment,e),Nd=p(e),ze=n(e,"H4",{class:!0});var Ic=l(ze);Pa=n(Ic,"A",{id:!0,class:!0,href:!0});var I2=l(Pa);El=n(I2,"SPAN",{});var B2=l(El);E(Wo.$$.fragment,B2),B2.forEach(o),I2.forEach(o),wv=p(Ic),$l=n(Ic,"SPAN",{});var X2=l($l);kv=s(X2,"Usar un modelo rastreado para la inferencia"),X2.forEach(o),Ic.forEach(o),Pd=p(e),Aa=n(e,"P",{});var Bc=l(Aa);Tv=s(Bc,"Usar el modelo rastreado para la inferencia es tan simple como usar su m\xE9todo "),bl=n(Bc,"CODE",{});var R2=l(bl);Ov=s(R2,"__call__"),R2.forEach(o),Nv=s(Bc,":"),Bc.forEach(o),Ad=p(e),E(Vo.$$.fragment,e),Cd=p(e),Se=n(e,"H3",{class:!0});var Xc=l(Se);Ca=n(Xc,"A",{id:!0,class:!0,href:!0});var F2=l(Ca);xl=n(F2,"SPAN",{});var H2=l(xl);E(Ko.$$.fragment,H2),H2.forEach(o),F2.forEach(o),Pv=p(Xc),yl=n(Xc,"SPAN",{});var U2=l(yl);Av=s(U2,"Implementar los modelos HuggingFace TorchScript en AWS mediante Neuron SDK"),U2.forEach(o),Xc.forEach(o),Dd=p(e),_e=n(e,"P",{});var ts=l(_e);Cv=s(ts,"AWS present\xF3 la familia de instancias "),Go=n(ts,"A",{href:!0,rel:!0});var W2=l(Go);Dv=s(W2,"Amazon EC2 Inf1"),W2.forEach(o),zv=s(ts,` para la inferencia
de aprendizaje autom\xE1tico de bajo costo y  alto rendimiento en la nube. Las instancias Inf1 funcionan con el chip AWS
Inferentia, un acelerador de hardware personalizado,  que se especializa en cargas de trabajo de inferencia de aprendizaje
profundo. `),Jo=n(ts,"A",{href:!0,rel:!0});var V2=l(Jo);Sv=s(V2,"AWS Neuron"),V2.forEach(o),Lv=s(ts,` es el kit de desarrollo para  Inferentia
que admite el rastreo y la optimizaci\xF3n de modelos de  transformers para su implementaci\xF3n en Inf1. El SDK de Neuron proporciona:`),ts.forEach(o),zd=p(e),ve=n(e,"OL",{});var ss=l(ve);jl=n(ss,"LI",{});var K2=l(jl);Mv=s(K2,"API f\xE1cil de usar con una l\xEDnea de cambio de c\xF3digo para rastrear y optimizar un modelo de TorchScript para la inferencia en la nube."),K2.forEach(o),Iv=p(ss),Rt=n(ss,"LI",{});var Sg=l(Rt);Bv=s(Sg,"Optimizaciones de rendimiento listas para usar con un "),Yo=n(Sg,"A",{href:!0,rel:!0});var G2=l(Yo);Xv=s(G2,"costo-rendimiento mejorado"),G2.forEach(o),Sg.forEach(o),Rv=p(ss),Le=n(ss,"LI",{});var rs=l(Le);Fv=s(rs,"Soporte para modelos HuggingFace Transformers construidos con "),Qo=n(rs,"A",{href:!0,rel:!0});var J2=l(Qo);Hv=s(J2,"PyTorch"),J2.forEach(o),Uv=s(rs,`
o `),Zo=n(rs,"A",{href:!0,rel:!0});var Y2=l(Zo);Wv=s(Y2,"TensorFlow"),Y2.forEach(o),Vv=s(rs,"."),rs.forEach(o),ss.forEach(o),Sd=p(e),Me=n(e,"H4",{class:!0});var Rc=l(Me);Da=n(Rc,"A",{id:!0,class:!0,href:!0});var Q2=l(Da);ql=n(Q2,"SPAN",{});var Z2=l(ql);E(et.$$.fragment,Z2),Z2.forEach(o),Q2.forEach(o),Kv=p(Rc),wl=n(Rc,"SPAN",{});var eb=l(wl);Gv=s(eb,"Implicaciones"),eb.forEach(o),Rc.forEach(o),Ld=p(e),F=n(e,"P",{});var se=l(F);Jv=s(se,`Los modelos Transformers basados en la arquitectura
`),Ie=n(se,"A",{href:!0,rel:!0});var Fc=l(Ie);Yv=s(Fc,"BERT (Representaciones de "),kl=n(Fc,"EM",{});var ab=l(kl);Qv=s(ab,"Enconder"),ab.forEach(o),Zv=s(Fc," bidireccional de Transformers)"),Fc.forEach(o),eg=s(se,`,
o sus variantes, como `),at=n(se,"A",{href:!0,rel:!0});var ob=l(at);ag=s(ob,"distilBERT"),ob.forEach(o),og=s(se,` y
`),ot=n(se,"A",{href:!0,rel:!0});var tb=l(ot);tg=s(tb,"roBERTa"),tb.forEach(o),sg=s(se,`, se ejecutar\xE1n mejor en Inf1 para tareas no
generativas, como la respuesta extractiva de preguntas, la clasificaci\xF3n de secuencias y la clasificaci\xF3n de tokens.
Como alternativa, las tareas de generaci\xF3n de texto se pueden adaptar para ejecutarse en Inf1, seg\xFAn este
`),tt=n(se,"A",{href:!0,rel:!0});var sb=l(tt);rg=s(sb,"tutorial de AWS Neuron MarianMT"),sb.forEach(o),ng=s(se,`.
Puedes encontrar m\xE1s informaci\xF3n sobre los modelos que est\xE1n listos para usarse en Inferentia en la
`),Be=n(se,"A",{href:!0,rel:!0});var Hc=l(Be);lg=s(Hc,"secci\xF3n "),Tl=n(Hc,"EM",{});var rb=l(Tl);ig=s(rb,"Model Architecture Fit"),rb.forEach(o),dg=s(Hc," de la documentaci\xF3n de Neuron"),Hc.forEach(o),cg=s(se,"."),se.forEach(o),Md=p(e),Xe=n(e,"H4",{class:!0});var Uc=l(Xe);za=n(Uc,"A",{id:!0,class:!0,href:!0});var nb=l(za);Ol=n(nb,"SPAN",{});var lb=l(Ol);E(st.$$.fragment,lb),lb.forEach(o),nb.forEach(o),pg=p(Uc),Nl=n(Uc,"SPAN",{});var ib=l(Nl);ug=s(ib,"Dependencias"),ib.forEach(o),Uc.forEach(o),Id=p(e),Ft=n(e,"P",{});var db=l(Ft);mg=s(db,"Usar AWS Neuron para convertir modelos requiere las siguientes dependencias y entornos:"),db.forEach(o),Bd=p(e),Ht=n(e,"UL",{});var cb=l(Ht);Re=n(cb,"LI",{});var ns=l(Re);fg=s(ns,"Un "),rt=n(ns,"A",{href:!0,rel:!0});var pb=l(rt);hg=s(pb,"entorno Neuron SDK"),pb.forEach(o),_g=s(ns,`,
que viene preconfigurado en `),nt=n(ns,"A",{href:!0,rel:!0});var ub=l(nt);vg=s(ub,"AWS Deep Learning AMI"),ub.forEach(o),gg=s(ns,"."),ns.forEach(o),cb.forEach(o),Xd=p(e),Fe=n(e,"H4",{class:!0});var Wc=l(Fe);Sa=n(Wc,"A",{id:!0,class:!0,href:!0});var mb=l(Sa);Pl=n(mb,"SPAN",{});var fb=l(Pl);E(lt.$$.fragment,fb),fb.forEach(o),mb.forEach(o),Eg=p(Wc),Al=n(Wc,"SPAN",{});var hb=l(Al);$g=s(hb,"Convertir un modelo a AWS Neuron"),hb.forEach(o),Wc.forEach(o),Rd=p(e),oe=n(e,"P",{});var Fa=l(oe);bg=s(Fa,"Con el mismo script usado en "),it=n(Fa,"A",{href:!0,rel:!0});var _b=l(it);xg=s(_b,"Uso de TorchScript en Python"),_b.forEach(o),yg=s(Fa,`
para rastrear un \u201CBertModel\u201D, puedes importar la extensi\xF3n del `),Cl=n(Fa,"EM",{});var vb=l(Cl);jg=s(vb,"framework"),vb.forEach(o),qg=p(Fa),Dl=n(Fa,"CODE",{});var gb=l(Dl);wg=s(gb,"torch.neuron"),gb.forEach(o),kg=s(Fa,` para acceder a los componentes
del SDK de Neuron a trav\xE9s de una API de Python.`),Fa.forEach(o),Fd=p(e),E(dt.$$.fragment,e),Hd=p(e),Ut=n(e,"P",{});var Eb=l(Ut);Tg=s(Eb,"Y modificando la l\xEDnea de c\xF3digo de rastreo de:"),Eb.forEach(o),Ud=p(e),E(ct.$$.fragment,e),Wd=p(e),Wt=n(e,"P",{});var $b=l(Wt);Og=s($b,"con lo siguiente:"),$b.forEach(o),Vd=p(e),E(pt.$$.fragment,e),Kd=p(e),Vt=n(e,"P",{});var bb=l(Vt);Ng=s(bb,"Este cambio permite a Neuron SDK rastrear el modelo y optimizarlo para ejecutarse en instancias Inf1."),bb.forEach(o),Gd=p(e),La=n(e,"P",{});var Vc=l(La);Pg=s(Vc,`Para obtener m\xE1s informaci\xF3n sobre las funciones, las herramientas, los tutoriales de ejemplo y las \xFAltimas actualizaciones
de AWS Neuron SDK, consulte la `),ut=n(Vc,"A",{href:!0,rel:!0});var xb=l(ut);Ag=s(xb,"documentaci\xF3n de AWS NeuronSDK"),xb.forEach(o),Cg=s(Vc,"."),Vc.forEach(o),this.h()},h(){u(m,"name","hf:doc:metadata"),u(m,"content",JSON.stringify(Rb)),u(j,"id","exportar-modelos-transformers"),u(j,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(j,"href","#exportar-modelos-transformers"),u(_,"class","relative group"),u(re,"href","https://github.com/huggingface/optimum"),u(re,"rel","nofollow"),u(U,"id","onnx"),u(U,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(U,"href","#onnx"),u(J,"class","relative group"),u(Wa,"href","http://onnx.ai"),u(Wa,"rel","nofollow"),u(Je,"id","exportar-un-model-a-onnx"),u(Je,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(Je,"href","#exportar-un-model-a-onnx"),u(xe,"class","relative group"),u(Za,"href","https://onnx.ai/supported-tools.html#deployModel"),u(Za,"rel","nofollow"),u(eo,"href","https://onnxruntime.ai/"),u(eo,"rel","nofollow"),u(to,"href","https://huggingface.co/keras-io"),u(to,"rel","nofollow"),u(aa,"id","seleccionar-caractersticas-para-diferentes-topologas-de-un-modelo"),u(aa,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(aa,"href","#seleccionar-caractersticas-para-diferentes-topologas-de-un-modelo"),u(ye,"class","relative group"),u(na,"id","exportar-un-modelo-para-una-arquitectura-no-compatible"),u(na,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(na,"href","#exportar-un-modelo-para-una-arquitectura-no-compatible"),u(je,"class","relative group"),u(la,"id","implementar-una-configuracin-personalizada-en-onnx"),u(la,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(la,"href","#implementar-una-configuracin-personalizada-en-onnx"),u(qe,"class","relative group"),u(fa,"id","exportar-el-modelo"),u(fa,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(fa,"href","#exportar-el-modelo"),u(we,"class","relative group"),u(_a,"id","validar-los-resultados-del-modelo"),u(_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"),u(_a,"href","#validar-los-resultados-del-modelo"),u(ke,"class","relative group"),u(ga,"id","contribuir-con-una-nueva-configuracin-a-transformers"),u(ga,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(ga,"href","#contribuir-con-una-nueva-configuracin-a-transformers"),u(Te,"class","relative group"),u(zo,"href","https://github.com/huggingface/transformers/pull/14868/files"),u(zo,"rel","nofollow"),u($a,"id","torchscript"),u($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"),u($a,"href","#torchscript"),u(Oe,"class","relative group"),u(Lo,"href","https://pytorch.org/docs/stable/jit.html"),u(Lo,"rel","nofollow"),u(ja,"id","indicador-de-torchscript-y-pesos-atados"),u(ja,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(ja,"href","#indicador-de-torchscript-y-pesos-atados"),u(Ne,"class","relative group"),u(wa,"id","entradas-ficticias-y-longitudes-estndar"),u(wa,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(wa,"href","#entradas-ficticias-y-longitudes-estndar"),u(Pe,"class","relative group"),u(Ta,"id","usar-torchscript-en-python"),u(Ta,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(Ta,"href","#usar-torchscript-en-python"),u(Ae,"class","relative group"),u(Oa,"id","guardando-un-modelo"),u(Oa,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(Oa,"href","#guardando-un-modelo"),u(Ce,"class","relative group"),u(Na,"id","cargar-un-modelo"),u(Na,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(Na,"href","#cargar-un-modelo"),u(De,"class","relative group"),u(Pa,"id","usar-un-modelo-rastreado-para-la-inferencia"),u(Pa,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(Pa,"href","#usar-un-modelo-rastreado-para-la-inferencia"),u(ze,"class","relative group"),u(Ca,"id","implementar-los-modelos-huggingface-torchscript-en-aws-mediante-neuron-sdk"),u(Ca,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(Ca,"href","#implementar-los-modelos-huggingface-torchscript-en-aws-mediante-neuron-sdk"),u(Se,"class","relative group"),u(Go,"href","https://aws.amazon.com/ec2/instance-types/inf1/"),u(Go,"rel","nofollow"),u(Jo,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/#"),u(Jo,"rel","nofollow"),u(Yo,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/benchmark/%3E"),u(Yo,"rel","nofollow"),u(Qo,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/pytorch/bert_tutorial/tutorial_pretrained_bert.html"),u(Qo,"rel","nofollow"),u(Zo,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/tensorflow/huggingface_bert/huggingface_bert.html"),u(Zo,"rel","nofollow"),u(Da,"id","implicaciones"),u(Da,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(Da,"href","#implicaciones"),u(Me,"class","relative group"),u(Ie,"href","https://huggingface.co/docs/transformers/main/model_doc/bert"),u(Ie,"rel","nofollow"),u(at,"href","https://huggingface.co/docs/transformers/main/model_doc/distilbert"),u(at,"rel","nofollow"),u(ot,"href","https://huggingface.co/docs/transformers/main/model_doc/roberta"),u(ot,"rel","nofollow"),u(tt,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/pytorch/transformers-marianmt.html"),u(tt,"rel","nofollow"),u(Be,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/models/models-inferentia.html#models-inferentia"),u(Be,"rel","nofollow"),u(za,"id","dependencias"),u(za,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(za,"href","#dependencias"),u(Xe,"class","relative group"),u(rt,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html#installation-guide"),u(rt,"rel","nofollow"),u(nt,"href","https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-inferentia-launching.html"),u(nt,"rel","nofollow"),u(Sa,"id","convertir-un-modelo-a-aws-neuron"),u(Sa,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(Sa,"href","#convertir-un-modelo-a-aws-neuron"),u(Fe,"class","relative group"),u(it,"href","https://huggingface.co/docs/transformers/main/es/serialization#using-torchscript-in-python"),u(it,"rel","nofollow"),u(ut,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/index.html"),u(ut,"rel","nofollow")},m(e,i){a(document.head,m),d(e,q,i),d(e,_,i),a(_,j),a(j,k),$(w,k,null),a(_,A),a(_,N),a(N,P),d(e,C,i),d(e,S,i),a(S,O),d(e,D,i),d(e,v,i),a(v,T),a(v,B),a(B,G),a(v,$e),a(v,re),a(re,Ha),a(v,be),d(e,We,i),d(e,J,i),a(J,U),a(U,L),$(ne,L,null),a(J,ft),a(J,Ve),a(Ve,ht),d(e,Ua,i),d(e,H,i),a(H,_t),a(H,Wa),a(Wa,Kc),a(H,Gc),a(H,is),a(is,Jc),a(H,Yc),a(H,ds),a(ds,Qc),a(H,Zc),d(e,Fl,i),d(e,vt,i),a(vt,ep),d(e,Hl,i),d(e,Ke,i),a(Ke,ap),a(Ke,cs),a(cs,op),a(Ke,tp),d(e,Ul,i),d(e,gt,i),a(gt,sp),d(e,Wl,i),d(e,f,i),a(f,ps),a(ps,rp),a(f,np),a(f,us),a(us,lp),a(f,ip),a(f,ms),a(ms,dp),a(f,cp),a(f,fs),a(fs,pp),a(f,up),a(f,hs),a(hs,mp),a(f,fp),a(f,_s),a(_s,hp),a(f,_p),a(f,vs),a(vs,vp),a(f,gp),a(f,gs),a(gs,Ep),a(f,$p),a(f,Es),a(Es,bp),a(f,xp),a(f,$s),a($s,yp),a(f,jp),a(f,bs),a(bs,qp),a(f,wp),a(f,xs),a(xs,kp),a(f,Tp),a(f,ys),a(ys,Op),a(f,Np),a(f,js),a(js,Pp),a(f,Ap),a(f,qs),a(qs,Cp),a(f,Dp),a(f,ws),a(ws,zp),a(f,Sp),a(f,ks),a(ks,Lp),a(f,Mp),a(f,Ts),a(Ts,Ip),a(f,Bp),a(f,Os),a(Os,Xp),a(f,Rp),a(f,Ns),a(Ns,Fp),a(f,Hp),a(f,Ps),a(Ps,Up),a(f,Wp),a(f,As),a(As,Vp),a(f,Kp),a(f,Cs),a(Cs,Gp),a(f,Jp),a(f,Ds),a(Ds,Yp),a(f,Qp),a(f,zs),a(zs,Zp),a(f,eu),a(f,Ss),a(Ss,au),a(f,ou),a(f,Ls),a(Ls,tu),a(f,su),a(f,Ms),a(Ms,ru),a(f,nu),a(f,Is),a(Is,lu),a(f,iu),a(f,Bs),a(Bs,du),a(f,cu),a(f,Xs),a(Xs,pu),a(f,uu),a(f,Rs),a(Rs,mu),a(f,fu),a(f,Fs),a(Fs,hu),a(f,_u),a(f,Hs),a(Hs,vu),a(f,gu),a(f,Us),a(Us,Eu),a(f,$u),a(f,Ws),a(Ws,bu),a(f,xu),a(f,Vs),a(Vs,yu),a(f,ju),a(f,Ks),a(Ks,qu),a(f,wu),a(f,Gs),a(Gs,ku),a(f,Tu),a(f,Js),a(Js,Ou),a(f,Nu),a(f,Ys),a(Ys,Pu),a(f,Au),a(f,Qs),a(Qs,Cu),a(f,Du),a(f,Zs),a(Zs,zu),a(f,Su),a(f,er),a(er,Lu),a(f,Mu),a(f,ar),a(ar,Iu),a(f,Bu),a(f,or),a(or,Xu),a(f,Ru),a(f,tr),a(tr,Fu),a(f,Hu),a(f,sr),a(sr,Uu),a(f,Wu),a(f,rr),a(rr,Vu),d(e,Vl,i),d(e,Et,i),a(Et,Ku),d(e,Kl,i),d(e,Ge,i),a(Ge,Va),a(Va,Gu),a(Va,nr),a(nr,Ju),a(Va,Yu),a(Ge,Qu),a(Ge,lr),a(lr,Zu),d(e,Gl,i),d(e,xe,i),a(xe,Je),a(Je,ir),$(Ka,ir,null),a(xe,em),a(xe,dr),a(dr,am),d(e,Jl,i),d(e,$t,i),a($t,om),d(e,Yl,i),$(Ga,e,i),d(e,Ql,i),d(e,Ye,i),a(Ye,tm),a(Ye,cr),a(cr,sm),a(Ye,rm),d(e,Zl,i),$(Ja,e,i),d(e,ei,i),d(e,bt,i),a(bt,nm),d(e,ai,i),$(Ya,e,i),d(e,oi,i),d(e,xt,i),a(xt,lm),d(e,ti,i),$(Qa,e,i),d(e,si,i),d(e,le,i),a(le,im),a(le,pr),a(pr,dm),a(le,cm),a(le,ur),a(ur,pm),a(le,um),d(e,ri,i),d(e,Q,i),a(Q,mm),a(Q,mr),a(mr,fm),a(Q,hm),a(Q,Za),a(Za,_m),a(Q,vm),a(Q,eo),a(eo,gm),a(Q,Em),d(e,ni,i),$(ao,e,i),d(e,li,i),d(e,Qe,i),a(Qe,$m),a(Qe,fr),a(fr,bm),a(Qe,xm),d(e,ii,i),$(oo,e,i),d(e,di,i),d(e,Ze,i),a(Ze,ym),a(Ze,to),a(to,jm),a(Ze,qm),d(e,ci,i),$(so,e,i),d(e,pi,i),d(e,yt,i),a(yt,wm),d(e,ui,i),$(ea,e,i),d(e,mi,i),d(e,ye,i),a(ye,aa),a(aa,hr),$(ro,hr,null),a(ye,km),a(ye,_r),a(_r,Tm),d(e,fi,i),d(e,oa,i),a(oa,Om),a(oa,vr),a(vr,Nm),a(oa,Pm),d(e,hi,i),d(e,ta,i),a(ta,gr),a(gr,no),a(no,Er),a(Er,Am),a(no,Cm),a(no,$r),a($r,Dm),a(ta,zm),a(ta,X),a(X,lo),a(lo,io),a(io,br),a(br,Sm),a(io,Lm),a(io,xr),a(xr,Mm),a(lo,Im),a(lo,yr),a(yr,jr),a(jr,Bm),a(X,Xm),a(X,co),a(co,po),a(po,qr),a(qr,Rm),a(po,Fm),a(po,wr),a(wr,Hm),a(co,Um),a(co,kr),a(kr,Tr),a(Tr,Wm),a(X,Vm),a(X,uo),a(uo,Or),a(Or,Nr),a(Nr,Km),a(uo,Gm),a(uo,Pr),a(Pr,Ar),a(Ar,Jm),a(X,Ym),a(X,mo),a(mo,Cr),a(Cr,Dr),a(Dr,Qm),a(mo,Zm),a(mo,zr),a(zr,Sr),a(Sr,ef),a(X,af),a(X,fo),a(fo,ho),a(ho,Lr),a(Lr,of),a(ho,tf),a(ho,Mr),a(Mr,sf),a(fo,rf),a(fo,Ir),a(Ir,Br),a(Br,nf),a(X,lf),a(X,_o),a(_o,Xr),a(Xr,Rr),a(Rr,df),a(_o,cf),a(_o,Fr),a(Fr,Hr),a(Hr,pf),a(X,uf),a(X,vo),a(vo,Ur),a(Ur,Wr),a(Wr,mf),a(vo,ff),a(vo,Vr),a(Vr,Kr),a(Kr,hf),d(e,_i,i),d(e,sa,i),a(sa,_f),a(sa,Gr),a(Gr,vf),a(sa,gf),d(e,vi,i),$(go,e,i),d(e,gi,i),d(e,ie,i),a(ie,Ef),a(ie,Jr),a(Jr,$f),a(ie,bf),a(ie,Yr),a(Yr,xf),a(ie,yf),d(e,Ei,i),$(Eo,e,i),d(e,$i,i),d(e,jt,i),a(jt,jf),d(e,bi,i),$($o,e,i),d(e,xi,i),d(e,Z,i),a(Z,qf),a(Z,Qr),a(Qr,wf),a(Z,kf),a(Z,Zr),a(Zr,Tf),a(Z,Of),a(Z,en),a(en,Nf),a(Z,Pf),d(e,yi,i),$(ra,e,i),d(e,ji,i),d(e,je,i),a(je,na),a(na,an),$(bo,an,null),a(je,Af),a(je,on),a(on,Cf),d(e,qi,i),d(e,qt,i),a(qt,Df),d(e,wi,i),d(e,de,i),a(de,tn),a(tn,zf),a(de,Sf),a(de,sn),a(sn,Lf),a(de,Mf),a(de,rn),a(rn,If),d(e,ki,i),d(e,wt,i),a(wt,Bf),d(e,Ti,i),d(e,qe,i),a(qe,la),a(la,nn),$(xo,nn,null),a(qe,Xf),a(qe,ln),a(ln,Rf),d(e,Oi,i),d(e,kt,i),a(kt,Ff),d(e,Ni,i),d(e,ce,i),a(ce,ia),a(ia,Hf),a(ia,dn),a(dn,Uf),a(ia,Wf),a(ia,cn),a(cn,Vf),a(ce,Kf),a(ce,da),a(da,Gf),a(da,pn),a(pn,Jf),a(da,Yf),a(da,un),a(un,Qf),a(ce,Zf),a(ce,ca),a(ca,eh),a(ca,mn),a(mn,ah),a(ca,oh),a(ca,fn),a(fn,th),d(e,Pi,i),$(pa,e,i),d(e,Ai,i),d(e,pe,i),a(pe,sh),a(pe,hn),a(hn,rh),a(pe,nh),a(pe,_n),a(_n,lh),a(pe,ih),d(e,Ci,i),$(yo,e,i),d(e,Di,i),d(e,W,i),a(W,dh),a(W,vn),a(vn,ch),a(W,ph),a(W,gn),a(gn,uh),a(W,mh),a(W,En),a(En,fh),a(W,hh),a(W,$n),a($n,_h),a(W,vh),d(e,zi,i),$(ua,e,i),d(e,Si,i),d(e,Tt,i),a(Tt,gh),d(e,Li,i),$(jo,e,i),d(e,Mi,i),d(e,Ot,i),a(Ot,Eh),d(e,Ii,i),$(qo,e,i),d(e,Bi,i),d(e,Nt,i),a(Nt,$h),d(e,Xi,i),$(wo,e,i),d(e,Ri,i),d(e,V,i),a(V,bh),a(V,bn),a(bn,xh),a(V,yh),a(V,xn),a(xn,jh),a(V,qh),a(V,yn),a(yn,wh),a(V,kh),a(V,jn),a(jn,Th),a(V,Oh),d(e,Fi,i),$(ko,e,i),d(e,Hi,i),$(ma,e,i),d(e,Ui,i),d(e,we,i),a(we,fa),a(fa,qn),$(To,qn,null),a(we,Nh),a(we,wn),a(wn,Ph),d(e,Wi,i),d(e,ue,i),a(ue,Ah),a(ue,kn),a(kn,Ch),a(ue,Dh),a(ue,Tn),a(Tn,zh),a(ue,Sh),d(e,Vi,i),$(Oo,e,i),d(e,Ki,i),d(e,R,i),a(R,Lh),a(R,On),a(On,Mh),a(R,Ih),a(R,Nn),a(Nn,Bh),a(R,Xh),a(R,Pn),a(Pn,Rh),a(R,Fh),a(R,An),a(An,Hh),a(R,Uh),a(R,Cn),a(Cn,Wh),a(R,Vh),d(e,Gi,i),$(No,e,i),d(e,Ji,i),$(ha,e,i),d(e,Yi,i),d(e,ke,i),a(ke,_a),a(_a,Dn),$(Po,Dn,null),a(ke,Kh),a(ke,zn),a(zn,Gh),d(e,Qi,i),d(e,me,i),a(me,Jh),a(me,Sn),a(Sn,Yh),a(me,Qh),a(me,Ln),a(Ln,Zh),a(me,e_),d(e,Zi,i),$(Ao,e,i),d(e,ed,i),d(e,va,i),a(va,a_),a(va,Mn),a(Mn,o_),a(va,t_),d(e,ad,i),d(e,Te,i),a(Te,ga),a(ga,In),$(Co,In,null),a(Te,s_),a(Te,Bn),a(Bn,r_),d(e,od,i),d(e,Pt,i),a(Pt,n_),d(e,td,i),d(e,fe,i),a(fe,Do),a(Do,l_),a(Do,Xn),a(Xn,i_),a(Do,d_),a(fe,c_),a(fe,At),a(At,p_),a(At,Rn),a(Rn,u_),a(fe,m_),a(fe,Ct),a(Ct,f_),a(Ct,Fn),a(Fn,h_),d(e,sd,i),d(e,Ea,i),a(Ea,__),a(Ea,zo),a(zo,v_),a(Ea,g_),d(e,rd,i),d(e,Oe,i),a(Oe,$a),a($a,Hn),$(So,Hn,null),a(Oe,E_),a(Oe,Un),a(Un,$_),d(e,nd,i),$(ba,e,i),d(e,ld,i),d(e,xa,i),a(xa,b_),a(xa,Lo),a(Lo,x_),a(xa,y_),d(e,id,i),d(e,Dt,i),a(Dt,j_),d(e,dd,i),d(e,zt,i),a(zt,q_),d(e,cd,i),d(e,ya,i),a(ya,Wn),a(Wn,w_),a(ya,k_),a(ya,Mo),a(Mo,T_),a(Mo,Vn),a(Vn,O_),a(Mo,N_),d(e,pd,i),d(e,St,i),a(St,P_),d(e,ud,i),d(e,Ne,i),a(Ne,ja),a(ja,Kn),$(Io,Kn,null),a(Ne,A_),a(Ne,Gn),a(Gn,C_),d(e,md,i),d(e,he,i),a(he,D_),a(he,Jn),a(Jn,z_),a(he,S_),a(he,Yn),a(Yn,L_),a(he,M_),d(e,fd,i),d(e,ee,i),a(ee,I_),a(ee,Qn),a(Qn,B_),a(ee,X_),a(ee,Zn),a(Zn,R_),a(ee,F_),a(ee,el),a(el,H_),a(ee,U_),d(e,hd,i),d(e,qa,i),a(qa,W_),a(qa,al),a(al,V_),a(qa,K_),d(e,_d,i),d(e,Pe,i),a(Pe,wa),a(wa,ol),$(Bo,ol,null),a(Pe,G_),a(Pe,tl),a(tl,J_),d(e,vd,i),d(e,Lt,i),a(Lt,Y_),d(e,gd,i),d(e,Mt,i),a(Mt,Q_),d(e,Ed,i),d(e,It,i),a(It,sl),a(sl,Z_),d(e,$d,i),d(e,ka,i),a(ka,ev),a(ka,rl),a(rl,av),a(ka,ov),d(e,bd,i),d(e,Bt,i),a(Bt,tv),d(e,xd,i),d(e,Ae,i),a(Ae,Ta),a(Ta,nl),$(Xo,nl,null),a(Ae,sv),a(Ae,ll),a(ll,rv),d(e,yd,i),d(e,Xt,i),a(Xt,nv),d(e,jd,i),d(e,Ce,i),a(Ce,Oa),a(Oa,il),$(Ro,il,null),a(Ce,lv),a(Ce,dl),a(dl,iv),d(e,qd,i),d(e,Y,i),a(Y,dv),a(Y,cl),a(cl,cv),a(Y,pv),a(Y,pl),a(pl,uv),a(Y,mv),a(Y,ul),a(ul,fv),a(Y,hv),a(Y,ml),a(ml,_v),d(e,wd,i),$(Fo,e,i),d(e,kd,i),d(e,De,i),a(De,Na),a(Na,fl),$(Ho,fl,null),a(De,vv),a(De,hl),a(hl,gv),d(e,Td,i),d(e,ae,i),a(ae,Ev),a(ae,_l),a(_l,$v),a(ae,bv),a(ae,vl),a(vl,xv),a(ae,yv),a(ae,gl),a(gl,jv),a(ae,qv),d(e,Od,i),$(Uo,e,i),d(e,Nd,i),d(e,ze,i),a(ze,Pa),a(Pa,El),$(Wo,El,null),a(ze,wv),a(ze,$l),a($l,kv),d(e,Pd,i),d(e,Aa,i),a(Aa,Tv),a(Aa,bl),a(bl,Ov),a(Aa,Nv),d(e,Ad,i),$(Vo,e,i),d(e,Cd,i),d(e,Se,i),a(Se,Ca),a(Ca,xl),$(Ko,xl,null),a(Se,Pv),a(Se,yl),a(yl,Av),d(e,Dd,i),d(e,_e,i),a(_e,Cv),a(_e,Go),a(Go,Dv),a(_e,zv),a(_e,Jo),a(Jo,Sv),a(_e,Lv),d(e,zd,i),d(e,ve,i),a(ve,jl),a(jl,Mv),a(ve,Iv),a(ve,Rt),a(Rt,Bv),a(Rt,Yo),a(Yo,Xv),a(ve,Rv),a(ve,Le),a(Le,Fv),a(Le,Qo),a(Qo,Hv),a(Le,Uv),a(Le,Zo),a(Zo,Wv),a(Le,Vv),d(e,Sd,i),d(e,Me,i),a(Me,Da),a(Da,ql),$(et,ql,null),a(Me,Kv),a(Me,wl),a(wl,Gv),d(e,Ld,i),d(e,F,i),a(F,Jv),a(F,Ie),a(Ie,Yv),a(Ie,kl),a(kl,Qv),a(Ie,Zv),a(F,eg),a(F,at),a(at,ag),a(F,og),a(F,ot),a(ot,tg),a(F,sg),a(F,tt),a(tt,rg),a(F,ng),a(F,Be),a(Be,lg),a(Be,Tl),a(Tl,ig),a(Be,dg),a(F,cg),d(e,Md,i),d(e,Xe,i),a(Xe,za),a(za,Ol),$(st,Ol,null),a(Xe,pg),a(Xe,Nl),a(Nl,ug),d(e,Id,i),d(e,Ft,i),a(Ft,mg),d(e,Bd,i),d(e,Ht,i),a(Ht,Re),a(Re,fg),a(Re,rt),a(rt,hg),a(Re,_g),a(Re,nt),a(nt,vg),a(Re,gg),d(e,Xd,i),d(e,Fe,i),a(Fe,Sa),a(Sa,Pl),$(lt,Pl,null),a(Fe,Eg),a(Fe,Al),a(Al,$g),d(e,Rd,i),d(e,oe,i),a(oe,bg),a(oe,it),a(it,xg),a(oe,yg),a(oe,Cl),a(Cl,jg),a(oe,qg),a(oe,Dl),a(Dl,wg),a(oe,kg),d(e,Fd,i),$(dt,e,i),d(e,Hd,i),d(e,Ut,i),a(Ut,Tg),d(e,Ud,i),$(ct,e,i),d(e,Wd,i),d(e,Wt,i),a(Wt,Og),d(e,Vd,i),$(pt,e,i),d(e,Kd,i),d(e,Vt,i),a(Vt,Ng),d(e,Gd,i),d(e,La,i),a(La,Pg),a(La,ut),a(ut,Ag),a(La,Cg),Jd=!0},p(e,[i]){const mt={};i&2&&(mt.$$scope={dirty:i,ctx:e}),ea.$set(mt);const zl={};i&2&&(zl.$$scope={dirty:i,ctx:e}),ra.$set(zl);const Sl={};i&2&&(Sl.$$scope={dirty:i,ctx:e}),pa.$set(Sl);const Ll={};i&2&&(Ll.$$scope={dirty:i,ctx:e}),ua.$set(Ll);const Ml={};i&2&&(Ml.$$scope={dirty:i,ctx:e}),ma.$set(Ml);const He={};i&2&&(He.$$scope={dirty:i,ctx:e}),ha.$set(He);const Il={};i&2&&(Il.$$scope={dirty:i,ctx:e}),ba.$set(Il)},i(e){Jd||(b(w.$$.fragment,e),b(ne.$$.fragment,e),b(Ka.$$.fragment,e),b(Ga.$$.fragment,e),b(Ja.$$.fragment,e),b(Ya.$$.fragment,e),b(Qa.$$.fragment,e),b(ao.$$.fragment,e),b(oo.$$.fragment,e),b(so.$$.fragment,e),b(ea.$$.fragment,e),b(ro.$$.fragment,e),b(go.$$.fragment,e),b(Eo.$$.fragment,e),b($o.$$.fragment,e),b(ra.$$.fragment,e),b(bo.$$.fragment,e),b(xo.$$.fragment,e),b(pa.$$.fragment,e),b(yo.$$.fragment,e),b(ua.$$.fragment,e),b(jo.$$.fragment,e),b(qo.$$.fragment,e),b(wo.$$.fragment,e),b(ko.$$.fragment,e),b(ma.$$.fragment,e),b(To.$$.fragment,e),b(Oo.$$.fragment,e),b(No.$$.fragment,e),b(ha.$$.fragment,e),b(Po.$$.fragment,e),b(Ao.$$.fragment,e),b(Co.$$.fragment,e),b(So.$$.fragment,e),b(ba.$$.fragment,e),b(Io.$$.fragment,e),b(Bo.$$.fragment,e),b(Xo.$$.fragment,e),b(Ro.$$.fragment,e),b(Fo.$$.fragment,e),b(Ho.$$.fragment,e),b(Uo.$$.fragment,e),b(Wo.$$.fragment,e),b(Vo.$$.fragment,e),b(Ko.$$.fragment,e),b(et.$$.fragment,e),b(st.$$.fragment,e),b(lt.$$.fragment,e),b(dt.$$.fragment,e),b(ct.$$.fragment,e),b(pt.$$.fragment,e),Jd=!0)},o(e){x(w.$$.fragment,e),x(ne.$$.fragment,e),x(Ka.$$.fragment,e),x(Ga.$$.fragment,e),x(Ja.$$.fragment,e),x(Ya.$$.fragment,e),x(Qa.$$.fragment,e),x(ao.$$.fragment,e),x(oo.$$.fragment,e),x(so.$$.fragment,e),x(ea.$$.fragment,e),x(ro.$$.fragment,e),x(go.$$.fragment,e),x(Eo.$$.fragment,e),x($o.$$.fragment,e),x(ra.$$.fragment,e),x(bo.$$.fragment,e),x(xo.$$.fragment,e),x(pa.$$.fragment,e),x(yo.$$.fragment,e),x(ua.$$.fragment,e),x(jo.$$.fragment,e),x(qo.$$.fragment,e),x(wo.$$.fragment,e),x(ko.$$.fragment,e),x(ma.$$.fragment,e),x(To.$$.fragment,e),x(Oo.$$.fragment,e),x(No.$$.fragment,e),x(ha.$$.fragment,e),x(Po.$$.fragment,e),x(Ao.$$.fragment,e),x(Co.$$.fragment,e),x(So.$$.fragment,e),x(ba.$$.fragment,e),x(Io.$$.fragment,e),x(Bo.$$.fragment,e),x(Xo.$$.fragment,e),x(Ro.$$.fragment,e),x(Fo.$$.fragment,e),x(Ho.$$.fragment,e),x(Uo.$$.fragment,e),x(Wo.$$.fragment,e),x(Vo.$$.fragment,e),x(Ko.$$.fragment,e),x(et.$$.fragment,e),x(st.$$.fragment,e),x(lt.$$.fragment,e),x(dt.$$.fragment,e),x(ct.$$.fragment,e),x(pt.$$.fragment,e),Jd=!1},d(e){o(m),e&&o(q),e&&o(_),y(w),e&&o(C),e&&o(S),e&&o(D),e&&o(v),e&&o(We),e&&o(J),y(ne),e&&o(Ua),e&&o(H),e&&o(Fl),e&&o(vt),e&&o(Hl),e&&o(Ke),e&&o(Ul),e&&o(gt),e&&o(Wl),e&&o(f),e&&o(Vl),e&&o(Et),e&&o(Kl),e&&o(Ge),e&&o(Gl),e&&o(xe),y(Ka),e&&o(Jl),e&&o($t),e&&o(Yl),y(Ga,e),e&&o(Ql),e&&o(Ye),e&&o(Zl),y(Ja,e),e&&o(ei),e&&o(bt),e&&o(ai),y(Ya,e),e&&o(oi),e&&o(xt),e&&o(ti),y(Qa,e),e&&o(si),e&&o(le),e&&o(ri),e&&o(Q),e&&o(ni),y(ao,e),e&&o(li),e&&o(Qe),e&&o(ii),y(oo,e),e&&o(di),e&&o(Ze),e&&o(ci),y(so,e),e&&o(pi),e&&o(yt),e&&o(ui),y(ea,e),e&&o(mi),e&&o(ye),y(ro),e&&o(fi),e&&o(oa),e&&o(hi),e&&o(ta),e&&o(_i),e&&o(sa),e&&o(vi),y(go,e),e&&o(gi),e&&o(ie),e&&o(Ei),y(Eo,e),e&&o($i),e&&o(jt),e&&o(bi),y($o,e),e&&o(xi),e&&o(Z),e&&o(yi),y(ra,e),e&&o(ji),e&&o(je),y(bo),e&&o(qi),e&&o(qt),e&&o(wi),e&&o(de),e&&o(ki),e&&o(wt),e&&o(Ti),e&&o(qe),y(xo),e&&o(Oi),e&&o(kt),e&&o(Ni),e&&o(ce),e&&o(Pi),y(pa,e),e&&o(Ai),e&&o(pe),e&&o(Ci),y(yo,e),e&&o(Di),e&&o(W),e&&o(zi),y(ua,e),e&&o(Si),e&&o(Tt),e&&o(Li),y(jo,e),e&&o(Mi),e&&o(Ot),e&&o(Ii),y(qo,e),e&&o(Bi),e&&o(Nt),e&&o(Xi),y(wo,e),e&&o(Ri),e&&o(V),e&&o(Fi),y(ko,e),e&&o(Hi),y(ma,e),e&&o(Ui),e&&o(we),y(To),e&&o(Wi),e&&o(ue),e&&o(Vi),y(Oo,e),e&&o(Ki),e&&o(R),e&&o(Gi),y(No,e),e&&o(Ji),y(ha,e),e&&o(Yi),e&&o(ke),y(Po),e&&o(Qi),e&&o(me),e&&o(Zi),y(Ao,e),e&&o(ed),e&&o(va),e&&o(ad),e&&o(Te),y(Co),e&&o(od),e&&o(Pt),e&&o(td),e&&o(fe),e&&o(sd),e&&o(Ea),e&&o(rd),e&&o(Oe),y(So),e&&o(nd),y(ba,e),e&&o(ld),e&&o(xa),e&&o(id),e&&o(Dt),e&&o(dd),e&&o(zt),e&&o(cd),e&&o(ya),e&&o(pd),e&&o(St),e&&o(ud),e&&o(Ne),y(Io),e&&o(md),e&&o(he),e&&o(fd),e&&o(ee),e&&o(hd),e&&o(qa),e&&o(_d),e&&o(Pe),y(Bo),e&&o(vd),e&&o(Lt),e&&o(gd),e&&o(Mt),e&&o(Ed),e&&o(It),e&&o($d),e&&o(ka),e&&o(bd),e&&o(Bt),e&&o(xd),e&&o(Ae),y(Xo),e&&o(yd),e&&o(Xt),e&&o(jd),e&&o(Ce),y(Ro),e&&o(qd),e&&o(Y),e&&o(wd),y(Fo,e),e&&o(kd),e&&o(De),y(Ho),e&&o(Td),e&&o(ae),e&&o(Od),y(Uo,e),e&&o(Nd),e&&o(ze),y(Wo),e&&o(Pd),e&&o(Aa),e&&o(Ad),y(Vo,e),e&&o(Cd),e&&o(Se),y(Ko),e&&o(Dd),e&&o(_e),e&&o(zd),e&&o(ve),e&&o(Sd),e&&o(Me),y(et),e&&o(Ld),e&&o(F),e&&o(Md),e&&o(Xe),y(st),e&&o(Id),e&&o(Ft),e&&o(Bd),e&&o(Ht),e&&o(Xd),e&&o(Fe),y(lt),e&&o(Rd),e&&o(oe),e&&o(Fd),y(dt,e),e&&o(Hd),e&&o(Ut),e&&o(Ud),y(ct,e),e&&o(Wd),e&&o(Wt),e&&o(Vd),y(pt,e),e&&o(Kd),e&&o(Vt),e&&o(Gd),e&&o(La)}}}const Rb={local:"exportar-modelos-transformers",sections:[{local:"onnx",sections:[{local:"exportar-un-model-a-onnx",title:"Exportar un model a ONNX"},{local:"seleccionar-caractersticas-para-diferentes-topologas-de-un-modelo",title:"Seleccionar caracter\xEDsticas para diferentes topolog\xEDas de un modelo"},{local:"exportar-un-modelo-para-una-arquitectura-no-compatible",sections:[{local:"implementar-una-configuracin-personalizada-en-onnx",title:"Implementar una configuraci\xF3n personalizada en ONNX"},{local:"exportar-el-modelo",title:"Exportar el modelo"},{local:"validar-los-resultados-del-modelo",title:"Validar los resultados del modelo"}],title:"Exportar un modelo para una arquitectura no compatible"},{local:"contribuir-con-una-nueva-configuracin-a-transformers",title:"Contribuir con una nueva configuraci\xF3n a \u{1F917} Transformers"}],title:"ONNX"},{local:"torchscript",sections:[{local:"indicador-de-torchscript-y-pesos-atados",title:"Indicador de TorchScript y pesos atados"},{local:"entradas-ficticias-y-longitudes-estndar",title:"Entradas ficticias y longitudes est\xE1ndar"},{local:"usar-torchscript-en-python",sections:[{local:"guardando-un-modelo",title:"Guardando un modelo"},{local:"cargar-un-modelo",title:"Cargar un modelo"},{local:"usar-un-modelo-rastreado-para-la-inferencia",title:"Usar un modelo rastreado para la inferencia"}],title:"Usar TorchScript en Python"},{local:"implementar-los-modelos-huggingface-torchscript-en-aws-mediante-neuron-sdk",sections:[{local:"implicaciones",title:"Implicaciones"},{local:"dependencias",title:"Dependencias"},{local:"convertir-un-modelo-a-aws-neuron",title:"Convertir un modelo a AWS Neuron"}],title:"Implementar los modelos HuggingFace TorchScript en AWS mediante Neuron SDK"}],title:"TorchScript"}],title:"Exportar modelos \u{1F917} Transformers"};function Fb(M){return Ob(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class Jb extends qb{constructor(m){super();wb(this,m,Fb,Xb,kb,{})}}export{Jb as default,Rb as metadata};
