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