import{S as J1,i as N1,s as I1,e as s,k as d,w as v,t as l,M as k1,c as n,d as t,m as p,a as r,x as b,h as o,b as u,G as a,g as c,y as E,q as j,o as w,B as _,v as A1,L as $1}from"../chunks/vendor-hf-doc-builder.js";import{T as no}from"../chunks/Tip-hf-doc-builder.js";import{I as q}from"../chunks/IconCopyLink-hf-doc-builder.js";import{C as B}from"../chunks/CodeBlock-hf-doc-builder.js";import{F as Z1,M as C1}from"../chunks/Markdown-hf-doc-builder.js";import"../chunks/IconTensorflow-hf-doc-builder.js";function B1(R){let m,T,M,g,$,U,k,N,I,A,x,J,Z;return m=new B({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Ub2tlbml6ZXIlMkMlMjBBdXRvTW9kZWxGb3JTZXF1ZW5jZUNsYXNzaWZpY2F0aW9uJTBBJTBBJTIzJTIwTG9hZCUyMHRva2VuaXplciUyMGFuZCUyMFB5VG9yY2glMjB3ZWlnaHRzJTIwZm9ybSUyMHRoZSUyMEh1YiUwQXRva2VuaXplciUyMCUzRCUyMEF1dG9Ub2tlbml6ZXIuZnJvbV9wcmV0cmFpbmVkKCUyMmRpc3RpbGJlcnQtYmFzZS11bmNhc2VkJTIyKSUwQXB0X21vZGVsJTIwJTNEJTIwQXV0b01vZGVsRm9yU2VxdWVuY2VDbGFzc2lmaWNhdGlvbi5mcm9tX3ByZXRyYWluZWQoJTIyZGlzdGlsYmVydC1iYXNlLXVuY2FzZWQlMjIpJTBBJTIzJTIwU2F2ZSUyMHRvJTIwZGlzayUwQXRva2VuaXplci5zYXZlX3ByZXRyYWluZWQoJTIybG9jYWwtcHQtY2hlY2twb2ludCUyMiklMEFwdF9tb2RlbC5zYXZlX3ByZXRyYWluZWQoJTIybG9jYWwtcHQtY2hlY2twb2ludCUyMik=",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>)`}}),J=new B({props:{code:"cHl0aG9uJTIwLW0lMjB0cmFuc2Zvcm1lcnMub25ueCUyMC0tbW9kZWwlM0Rsb2NhbC1wdC1jaGVja3BvaW50JTIwb25ueCUyRg==",highlighted:"python -m transformers.onnx --model=local-pt-checkpoint onnx/"}}),{c(){v(m.$$.fragment),T=d(),M=s("p"),g=l("Una vez que se guarda el checkpoint, podemos exportarlo a ONNX usando el argumento "),$=s("code"),U=l("--model"),k=l(`
del paquete `),N=s("code"),I=l("transformers.onnx"),A=l(" al directorio deseado:"),x=d(),v(J.$$.fragment)},l(y){b(m.$$.fragment,y),T=p(y),M=n(y,"P",{});var C=r(M);g=o(C,"Una vez que se guarda el checkpoint, podemos exportarlo a ONNX usando el argumento "),$=n(C,"CODE",{});var X=r($);U=o(X,"--model"),X.forEach(t),k=o(C,`
del paquete `),N=n(C,"CODE",{});var F=r(N);I=o(F,"transformers.onnx"),F.forEach(t),A=o(C," al directorio deseado:"),C.forEach(t),x=p(y),b(J.$$.fragment,y)},m(y,C){E(m,y,C),c(y,T,C),c(y,M,C),a(M,g),a(M,$),a($,U),a(M,k),a(M,N),a(N,I),a(M,A),c(y,x,C),E(J,y,C),Z=!0},p:$1,i(y){Z||(j(m.$$.fragment,y),j(J.$$.fragment,y),Z=!0)},o(y){w(m.$$.fragment,y),w(J.$$.fragment,y),Z=!1},d(y){_(m,y),y&&t(T),y&&t(M),y&&t(x),_(J,y)}}}function x1(R){let m,T;return m=new C1({props:{$$slots:{default:[B1]},$$scope:{ctx:R}}}),{c(){v(m.$$.fragment)},l(M){b(m.$$.fragment,M)},m(M,g){E(m,M,g),T=!0},p(M,g){const $={};g&2&&($.$$scope={dirty:g,ctx:M}),m.$set($)},i(M){T||(j(m.$$.fragment,M),T=!0)},o(M){w(m.$$.fragment,M),T=!1},d(M){_(m,M)}}}function W1(R){let m,T,M,g,$,U,k,N,I,A,x,J,Z;return m=new B({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Ub2tlbml6ZXIlMkMlMjBURkF1dG9Nb2RlbEZvclNlcXVlbmNlQ2xhc3NpZmljYXRpb24lMEElMEElMjMlMjBMb2FkJTIwdG9rZW5pemVyJTIwYW5kJTIwVGVuc29yRmxvdyUyMHdlaWdodHMlMjBmcm9tJTIwdGhlJTIwSHViJTBBdG9rZW5pemVyJTIwJTNEJTIwQXV0b1Rva2VuaXplci5mcm9tX3ByZXRyYWluZWQoJTIyZGlzdGlsYmVydC1iYXNlLXVuY2FzZWQlMjIpJTBBdGZfbW9kZWwlMjAlM0QlMjBURkF1dG9Nb2RlbEZvclNlcXVlbmNlQ2xhc3NpZmljYXRpb24uZnJvbV9wcmV0cmFpbmVkKCUyMmRpc3RpbGJlcnQtYmFzZS11bmNhc2VkJTIyKSUwQSUyMyUyMFNhdmUlMjB0byUyMGRpc2slMEF0b2tlbml6ZXIuc2F2ZV9wcmV0cmFpbmVkKCUyMmxvY2FsLXRmLWNoZWNrcG9pbnQlMjIpJTBBdGZfbW9kZWwuc2F2ZV9wcmV0cmFpbmVkKCUyMmxvY2FsLXRmLWNoZWNrcG9pbnQlMjIp",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>)`}}),J=new B({props:{code:"cHl0aG9uJTIwLW0lMjB0cmFuc2Zvcm1lcnMub25ueCUyMC0tbW9kZWwlM0Rsb2NhbC10Zi1jaGVja3BvaW50JTIwb25ueCUyRg==",highlighted:"python -m transformers.onnx --model=local-tf-checkpoint onnx/"}}),{c(){v(m.$$.fragment),T=d(),M=s("p"),g=l("Una vez que se guarda el checkpoint, podemos exportarlo a ONNX usando el argumento "),$=s("code"),U=l("--model"),k=l(`
del paquete `),N=s("code"),I=l("transformers.onnx"),A=l(" al directorio deseado:"),x=d(),v(J.$$.fragment)},l(y){b(m.$$.fragment,y),T=p(y),M=n(y,"P",{});var C=r(M);g=o(C,"Una vez que se guarda el checkpoint, podemos exportarlo a ONNX usando el argumento "),$=n(C,"CODE",{});var X=r($);U=o(X,"--model"),X.forEach(t),k=o(C,`
del paquete `),N=n(C,"CODE",{});var F=r(N);I=o(F,"transformers.onnx"),F.forEach(t),A=o(C," al directorio deseado:"),C.forEach(t),x=p(y),b(J.$$.fragment,y)},m(y,C){E(m,y,C),c(y,T,C),c(y,M,C),a(M,g),a(M,$),a($,U),a(M,k),a(M,N),a(N,I),a(M,A),c(y,x,C),E(J,y,C),Z=!0},p:$1,i(y){Z||(j(m.$$.fragment,y),j(J.$$.fragment,y),Z=!0)},o(y){w(m.$$.fragment,y),w(J.$$.fragment,y),Z=!1},d(y){_(m,y),y&&t(T),y&&t(M),y&&t(x),_(J,y)}}}function R1(R){let m,T;return m=new C1({props:{$$slots:{default:[W1]},$$scope:{ctx:R}}}),{c(){v(m.$$.fragment)},l(M){b(m.$$.fragment,M)},m(M,g){E(m,M,g),T=!0},p(M,g){const $={};g&2&&($.$$scope={dirty:g,ctx:M}),m.$set($)},i(M){T||(j(m.$$.fragment,M),T=!0)},o(M){w(m.$$.fragment,M),T=!1},d(M){_(m,M)}}}function q1(R){let m,T;return{c(){m=s("p"),T=l(`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){m=n(M,"P",{});var g=r(m);T=o(g,`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.`),g.forEach(t)},m(M,g){c(M,m,g),a(m,T)},d(M){M&&t(m)}}}function X1(R){let m,T,M,g,$;return{c(){m=s("p"),T=l(`Una buena manera de implementar una configuraci\xF3n personalizada en ONNX es observar la implementaci\xF3n
existente en el archivo `),M=s("code"),g=l("configuration_<model_name>.py"),$=l(" de una arquitectura similar.")},l(U){m=n(U,"P",{});var k=r(m);T=o(k,`Una buena manera de implementar una configuraci\xF3n personalizada en ONNX es observar la implementaci\xF3n
existente en el archivo `),M=n(k,"CODE",{});var N=r(M);g=o(N,"configuration_<model_name>.py"),N.forEach(t),$=o(k," de una arquitectura similar."),k.forEach(t)},m(U,k){c(U,m,k),a(m,T),a(m,M),a(M,g),a(m,$)},d(U){U&&t(m)}}}function z1(R){let m,T,M,g,$,U,k,N,I,A,x,J,Z,y,C,X,F,Ee,se,Va,je,Pe,Q;return{c(){m=s("p"),T=l("Observa que la propiedad "),M=s("code"),g=l("inputs"),$=l(" para "),U=s("code"),k=l("DistilBertOnnxConfig"),N=l(" devuelve un "),I=s("code"),A=l("OrderedDict"),x=l(`.
Esto nos asegura que las entradas coincidan con su posici\xF3n relativa dentro del m\xE9todo
`),J=s("code"),Z=l("PreTrainedModel.forward()"),y=l(" al rastrear el grafo. Recomendamos usar un "),C=s("code"),X=l("OrderedDict"),F=l(`
para las propiedades `),Ee=s("code"),se=l("inputs"),Va=l(" y "),je=s("code"),Pe=l("outputs"),Q=l(" al implementar configuraciones ONNX personalizadas.")},l(O){m=n(O,"P",{});var W=r(m);T=o(W,"Observa que la propiedad "),M=n(W,"CODE",{});var ne=r(M);g=o(ne,"inputs"),ne.forEach(t),$=o(W," para "),U=n(W,"CODE",{});var ml=r(U);k=o(ml,"DistilBertOnnxConfig"),ml.forEach(t),N=o(W," devuelve un "),I=n(W,"CODE",{});var De=r(I);A=o(De,"OrderedDict"),De.forEach(t),x=o(W,`.
Esto nos asegura que las entradas coincidan con su posici\xF3n relativa dentro del m\xE9todo
`),J=n(W,"CODE",{});var fl=r(J);Z=o(fl,"PreTrainedModel.forward()"),fl.forEach(t),y=o(W," al rastrear el grafo. Recomendamos usar un "),C=n(W,"CODE",{});var Oa=r(C);X=o(Oa,"OrderedDict"),Oa.forEach(t),F=o(W,`
para las propiedades `),Ee=n(W,"CODE",{});var V=r(Ee);se=o(V,"inputs"),V.forEach(t),Va=o(W," y "),je=n(W,"CODE",{});var hl=r(je);Pe=o(hl,"outputs"),hl.forEach(t),Q=o(W," al implementar configuraciones ONNX personalizadas."),W.forEach(t)},m(O,W){c(O,m,W),a(m,T),a(m,M),a(M,g),a(m,$),a(m,U),a(U,k),a(m,N),a(m,I),a(I,A),a(m,x),a(m,J),a(J,Z),a(m,y),a(m,C),a(C,X),a(m,F),a(m,Ee),a(Ee,se),a(m,Va),a(m,je),a(je,Pe),a(m,Q)},d(O){O&&t(m)}}}function G1(R){let m,T,M,g,$,U,k,N;return{c(){m=s("p"),T=l("Todas las propiedades base y m\xE9todos asociados con "),M=s("code"),g=l("OnnxConfig"),$=l(` y las
otras clases de configuraci\xF3n se pueden sobreescribir si es necesario.
Consulte `),U=s("code"),k=l("BartOnnxConfig"),N=l(" para ver un ejemplo avanzado.")},l(I){m=n(I,"P",{});var A=r(m);T=o(A,"Todas las propiedades base y m\xE9todos asociados con "),M=n(A,"CODE",{});var x=r(M);g=o(x,"OnnxConfig"),x.forEach(t),$=o(A,` y las
otras clases de configuraci\xF3n se pueden sobreescribir si es necesario.
Consulte `),U=n(A,"CODE",{});var J=r(U);k=o(J,"BartOnnxConfig"),J.forEach(t),N=o(A," para ver un ejemplo avanzado."),A.forEach(t)},m(I,A){c(I,m,A),a(m,T),a(m,M),a(M,g),a(m,$),a(m,U),a(U,k),a(m,N)},d(I){I&&t(m)}}}function S1(R){let m,T,M,g,$,U,k,N,I,A,x;return{c(){m=s("p"),T=l(`Si tu modelo tiene m\xE1s de 2GB, ver\xE1s que se crean muchos archivos adicionales durante la exportaci\xF3n.
Esto es `),M=s("em"),g=l("esperado"),$=l(" porque ONNX usa "),U=s("a"),k=l("B\xFAferes de protocolo"),N=l(`
para almacenar el modelo y \xE9stos tienen un l\xEDmite de tama\xF1o de 2 GB. Consulta la
`),I=s("a"),A=l("documentaci\xF3n de ONNX"),x=l(` para obtener
instrucciones sobre c\xF3mo cargar modelos con datos externos.`),this.h()},l(J){m=n(J,"P",{});var Z=r(m);T=o(Z,`Si tu modelo tiene m\xE1s de 2GB, ver\xE1s que se crean muchos archivos adicionales durante la exportaci\xF3n.
Esto es `),M=n(Z,"EM",{});var y=r(M);g=o(y,"esperado"),y.forEach(t),$=o(Z," porque ONNX usa "),U=n(Z,"A",{href:!0,rel:!0});var C=r(U);k=o(C,"B\xFAferes de protocolo"),C.forEach(t),N=o(Z,`
para almacenar el modelo y \xE9stos tienen un l\xEDmite de tama\xF1o de 2 GB. Consulta la
`),I=n(Z,"A",{href:!0,rel:!0});var X=r(I);A=o(X,"documentaci\xF3n de ONNX"),X.forEach(t),x=o(Z,` para obtener
instrucciones sobre c\xF3mo cargar modelos con datos externos.`),Z.forEach(t),this.h()},h(){u(U,"href","https://developers.google.com/protocol-buffers/"),u(U,"rel","nofollow"),u(I,"href","https://github.com/onnx/onnx/blob/master/docs/ExternalData.md"),u(I,"rel","nofollow")},m(J,Z){c(J,m,Z),a(m,T),a(m,M),a(M,g),a(m,$),a(m,U),a(U,k),a(m,N),a(m,I),a(I,A),a(m,x)},d(J){J&&t(m)}}}function V1(R){let m,T;return{c(){m=s("p"),T=l(`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){m=n(M,"P",{});var g=r(m);T=o(g,`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.`),g.forEach(t)},m(M,g){c(M,m,g),a(m,T)},d(M){M&&t(m)}}}function O1(R){let m,T,M,g,$,U,k,N,I,A,x,J,Z,y,C,X,F,Ee,se,Va,je,Pe,Q,O,W,ne,ml,De,fl,Oa,V,hl,Pa,Fd,Qd,ro,Hd,Yd,io,Kd,ep,Vr,Ml,ap,Or,Le,tp,co,lp,op,Pr,yl,sp,Dr,f,po,np,rp,uo,ip,cp,mo,dp,pp,fo,up,mp,ho,fp,hp,Mo,Mp,yp,yo,vp,bp,vo,Ep,jp,bo,wp,_p,Eo,gp,Tp,jo,Up,$p,wo,Cp,Jp,_o,Np,Ip,go,kp,Ap,To,Zp,Bp,Uo,xp,Wp,$o,Rp,qp,Co,Xp,zp,Jo,Gp,Sp,No,Vp,Op,Io,Pp,Dp,ko,Lp,Fp,Ao,Qp,Hp,Zo,Yp,Kp,Bo,eu,au,xo,tu,lu,Wo,ou,su,Ro,nu,ru,qo,iu,cu,Xo,du,pu,zo,uu,mu,Go,fu,hu,So,Mu,yu,Vo,vu,bu,Oo,Eu,ju,Po,wu,_u,Do,gu,Tu,Lo,Uu,$u,Fo,Cu,Ju,Qo,Nu,Iu,Ho,ku,Au,Yo,Zu,Bu,Ko,xu,Wu,es,Ru,qu,as,Xu,zu,ts,Gu,Su,ls,Vu,Ou,os,Pu,Du,ss,Lu,Fu,ns,Qu,Lr,vl,Hu,Fr,Fe,Da,Yu,rs,Ku,em,am,is,tm,Qr,we,Qe,cs,La,lm,ds,om,Hr,bl,sm,Yr,Fa,Kr,He,nm,ps,rm,im,ei,Qa,ai,El,cm,ti,Ha,li,jl,dm,oi,Ya,si,re,pm,us,um,mm,ms,fm,hm,ni,Y,Mm,fs,ym,vm,Ka,bm,Em,et,jm,wm,ri,at,ii,Ye,_m,hs,gm,Tm,ci,tt,di,Ke,Um,lt,$m,Cm,pi,ot,ui,wl,Jm,mi,ea,fi,_e,aa,Ms,st,Nm,ys,Im,hi,ta,km,vs,Am,Zm,Mi,la,bs,nt,Es,Bm,xm,js,Wm,Rm,z,rt,it,ws,qm,Xm,_s,zm,Gm,gs,Ts,Sm,Vm,ct,dt,Us,Om,Pm,$s,Dm,Lm,Cs,Js,Fm,Qm,pt,Ns,Is,Hm,Ym,ks,As,Km,ef,ut,Zs,Bs,af,tf,xs,Ws,lf,of,mt,ft,Rs,sf,nf,qs,rf,cf,Xs,zs,df,pf,ht,Gs,Ss,uf,mf,Vs,Os,ff,hf,Mt,Ps,Ds,Mf,yf,Ls,Fs,vf,yi,oa,bf,Qs,Ef,jf,vi,yt,bi,ie,wf,Hs,_f,gf,Ys,Tf,Uf,Ei,vt,ji,_l,$f,wi,bt,_i,K,Cf,Ks,Jf,Nf,en,If,kf,an,Af,Zf,gi,sa,Ti,ge,na,tn,Et,Bf,ln,xf,Ui,gl,Wf,$i,ce,on,Rf,qf,sn,Xf,zf,nn,Gf,Ci,Tl,Sf,Ji,Te,ra,rn,jt,Vf,cn,Of,Ni,Ul,Pf,Ii,de,ia,Df,dn,Lf,Ff,pn,Qf,Hf,ca,Yf,un,Kf,eh,mn,ah,th,da,lh,fn,oh,sh,hn,nh,ki,pa,Ai,pe,rh,Mn,ih,ch,yn,dh,ph,Zi,wt,Bi,P,uh,vn,mh,fh,bn,hh,Mh,En,yh,vh,jn,bh,Eh,xi,ua,Wi,$l,jh,Ri,_t,qi,Cl,wh,Xi,gt,zi,Jl,_h,Gi,Tt,Si,D,gh,wn,Th,Uh,_n,$h,Ch,gn,Jh,Nh,Tn,Ih,kh,Vi,Ut,Oi,ma,Pi,Ue,fa,Un,$t,Ah,$n,Zh,Di,ue,Bh,Cn,xh,Wh,Jn,Rh,qh,Li,Ct,Fi,G,Xh,Nn,zh,Gh,In,Sh,Vh,kn,Oh,Ph,An,Dh,Lh,Zn,Fh,Qh,Qi,Jt,Hi,ha,Yi,$e,Ma,Bn,Nt,Hh,xn,Yh,Ki,me,Kh,Wn,eM,aM,Rn,tM,lM,ec,It,ac,ya,oM,qn,sM,nM,tc,Ce,va,Xn,kt,rM,zn,iM,lc,Nl,cM,oc,fe,At,dM,Gn,pM,uM,mM,Il,fM,Sn,hM,MM,kl,yM,Vn,vM,sc,ba,bM,Zt,EM,jM,nc,Je,Ea,On,Bt,wM,Pn,_M,rc,ja,ic,wa,gM,xt,TM,UM,cc,Al,$M,dc,Zl,CM,pc,_a,Dn,JM,NM,Wt,IM,Ln,kM,AM,uc,Bl,ZM,mc,Ne,ga,Fn,Rt,BM,Qn,xM,fc,he,WM,Hn,RM,qM,Yn,XM,zM,hc,ee,GM,Kn,SM,VM,er,OM,PM,ar,DM,LM,Mc,Ta,FM,tr,QM,HM,yc,Ie,Ua,lr,qt,YM,or,KM,vc,xl,ey,bc,Wl,ay,Ec,Rl,sr,ty,jc,$a,ly,nr,oy,sy,wc,ql,ny,_c,ke,Ca,rr,Xt,ry,ir,iy,gc,Xl,cy,Tc,Ae,Ja,cr,zt,dy,dr,py,Uc,H,uy,pr,my,fy,ur,hy,My,mr,yy,vy,fr,by,$c,Gt,Cc,Ze,Na,hr,St,Ey,Mr,jy,Jc,ae,wy,yr,_y,gy,vr,Ty,Uy,br,$y,Cy,Nc,Vt,Ic,Be,Ia,Er,Ot,Jy,jr,Ny,kc,ka,Iy,wr,ky,Ay,Ac,Pt,Zc,xe,Aa,_r,Dt,Zy,gr,By,Bc,Me,xy,Lt,Wy,Ry,Ft,qy,Xy,xc,ye,Tr,zy,Gy,zl,Sy,Qt,Vy,Oy,We,Py,Ht,Dy,Ly,Yt,Fy,Qy,Wc,Re,Za,Ur,Kt,Hy,$r,Yy,Rc,S,Ky,qe,ev,Cr,av,tv,lv,el,ov,sv,al,nv,rv,tl,iv,cv,Xe,dv,Jr,pv,uv,mv,qc,ze,Ba,Nr,ll,fv,Ir,hv,Xc,Gl,Mv,zc,Sl,Ge,yv,ol,vv,bv,sl,Ev,jv,Gc,Se,xa,kr,nl,wv,Ar,_v,Sc,te,gv,rl,Tv,Uv,Zr,$v,Cv,Br,Jv,Nv,Vc,il,Oc,Vl,Iv,Pc,cl,Dc,Ol,kv,Lc,dl,Fc,Pl,Av,Qc,Wa,Zv,pl,Bv,xv,Hc;return U=new q({}),ne=new q({}),La=new q({}),Fa=new B({props:{code:"cGlwJTIwaW5zdGFsbCUyMHRyYW5zZm9ybWVycyU1Qm9ubnglNUQ=",highlighted:"pip install transformers[onnx]"}}),Qa=new B({props:{code:"cHl0aG9uJTIwLW0lMjB0cmFuc2Zvcm1lcnMub25ueCUyMC0taGVscCUwQSUwQXVzYWdlJTNBJTIwSHVnZ2luZyUyMEZhY2UlMjBUcmFuc2Zvcm1lcnMlMjBPTk5YJTIwZXhwb3J0ZXIlMjAlNUItaCU1RCUyMC1tJTIwTU9ERUwlMjAlNUItLWZlYXR1cmUlMjAlN0JjYXVzYWwtbG0lMkMlMjAuLi4lN0QlNUQlMjAlNUItLW9wc2V0JTIwT1BTRVQlNUQlMjAlNUItLWF0b2wlMjBBVE9MJTVEJTIwb3V0cHV0JTBBJTBBcG9zaXRpb25hbCUyMGFyZ3VtZW50cyUzQSUwQSUyMCUyMG91dHB1dCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMFBhdGglMjBpbmRpY2F0aW5nJTIwd2hlcmUlMjB0byUyMHN0b3JlJTIwZ2VuZXJhdGVkJTIwT05OWCUyMG1vZGVsLiUwQSUwQW9wdGlvbmFsJTIwYXJndW1lbnRzJTNBJTBBJTIwJTIwLWglMkMlMjAtLWhlbHAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjBzaG93JTIwdGhpcyUyMGhlbHAlMjBtZXNzYWdlJTIwYW5kJTIwZXhpdCUwQSUyMCUyMC1tJTIwTU9ERUwlMkMlMjAtLW1vZGVsJTIwTU9ERUwlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjBNb2RlbCUyMElEJTIwb24lMjBodWdnaW5nZmFjZS5jbyUyMG9yJTIwcGF0aCUyMG9uJTIwZGlzayUyMHRvJTIwbG9hZCUyMG1vZGVsJTIwZnJvbS4lMEElMjAlMjAtLWZlYXR1cmUlMjAlN0JjYXVzYWwtbG0lMkMlMjAuLi4lN0QlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjBUaGUlMjB0eXBlJTIwb2YlMjBmZWF0dXJlcyUyMHRvJTIwZXhwb3J0JTIwdGhlJTIwbW9kZWwlMjB3aXRoLiUwQSUyMCUyMC0tb3BzZXQlMjBPUFNFVCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyME9OTlglMjBvcHNldCUyMHZlcnNpb24lMjB0byUyMGV4cG9ydCUyMHRoZSUyMG1vZGVsJTIwd2l0aC4lMEElMjAlMjAtLWF0b2wlMjBBVE9MJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwQWJzb2x1dGUlMjBkaWZmZXJlbmNlJTIwdG9sZXJlbmNlJTIwd2hlbiUyMHZhbGlkYXRpbmclMjB0aGUlMjBtb2RlbC4=",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.`}}),Ha=new B({props:{code:"cHl0aG9uJTIwLW0lMjB0cmFuc2Zvcm1lcnMub25ueCUyMC0tbW9kZWwlM0RkaXN0aWxiZXJ0LWJhc2UtdW5jYXNlZCUyMG9ubnglMkY=",highlighted:"python -m transformers.onnx --model=distilbert-base-uncased onnx/"}}),Ya=new B({props:{code:"VmFsaWRhdGluZyUyME9OTlglMjBtb2RlbC4uLiUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMC0lNUIlRTIlOUMlOTMlNUQlMjBPTk5YJTIwbW9kZWwlMjBvdXRwdXQlMjBuYW1lcyUyMG1hdGNoJTIwcmVmZXJlbmNlJTIwbW9kZWwlMjAoJTdCJ2xhc3RfaGlkZGVuX3N0YXRlJyU3RCklMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAtJTIwVmFsaWRhdGluZyUyME9OTlglMjBNb2RlbCUyMG91dHB1dCUyMCUyMmxhc3RfaGlkZGVuX3N0YXRlJTIyJTNBJTBBJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwLSU1QiVFMiU5QyU5MyU1RCUyMCgyJTJDJTIwOCUyQyUyMDc2OCklMjBtYXRjaGVzJTIwKDIlMkMlMjA4JTJDJTIwNzY4KSUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMC0lNUIlRTIlOUMlOTMlNUQlMjBhbGwlMjB2YWx1ZXMlMjBjbG9zZSUyMChhdG9sJTNBJTIwMWUtMDUpJTBBQWxsJTIwZ29vZCUyQyUyMG1vZGVsJTIwc2F2ZWQlMjBhdCUzQSUyMG9ubnglMkZtb2RlbC5vbm54",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`}}),at=new B({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Ub2tlbml6ZXIlMEFmcm9tJTIwb25ueHJ1bnRpbWUlMjBpbXBvcnQlMjBJbmZlcmVuY2VTZXNzaW9uJTBBJTBBdG9rZW5pemVyJTIwJTNEJTIwQXV0b1Rva2VuaXplci5mcm9tX3ByZXRyYWluZWQoJTIyZGlzdGlsYmVydC1iYXNlLXVuY2FzZWQlMjIpJTBBc2Vzc2lvbiUyMCUzRCUyMEluZmVyZW5jZVNlc3Npb24oJTIyb25ueCUyRm1vZGVsLm9ubnglMjIpJTBBJTIzJTIwT05OWCUyMFJ1bnRpbWUlMjBleHBlY3RzJTIwTnVtUHklMjBhcnJheXMlMjBhcyUyMGlucHV0JTBBaW5wdXRzJTIwJTNEJTIwdG9rZW5pemVyKCUyMlVzaW5nJTIwRGlzdGlsQkVSVCUyMHdpdGglMjBPTk5YJTIwUnVudGltZSElMjIlMkMlMjByZXR1cm5fdGVuc29ycyUzRCUyMm5wJTIyKSUwQW91dHB1dHMlMjAlM0QlMjBzZXNzaW9uLnJ1bihvdXRwdXRfbmFtZXMlM0QlNUIlMjJsYXN0X2hpZGRlbl9zdGF0ZSUyMiU1RCUyQyUyMGlucHV0X2ZlZWQlM0RkaWN0KGlucHV0cykp",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))`}}),tt=new B({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycy5tb2RlbHMuZGlzdGlsYmVydCUyMGltcG9ydCUyMERpc3RpbEJlcnRDb25maWclMkMlMjBEaXN0aWxCZXJ0T25ueENvbmZpZyUwQSUwQWNvbmZpZyUyMCUzRCUyMERpc3RpbEJlcnRDb25maWcoKSUwQW9ubnhfY29uZmlnJTIwJTNEJTIwRGlzdGlsQmVydE9ubnhDb25maWcoY29uZmlnKSUwQXByaW50KGxpc3Qob25ueF9jb25maWcub3V0cHV0cy5rZXlzKCkpKQ==",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`}}),ot=new B({props:{code:"cHl0aG9uJTIwLW0lMjB0cmFuc2Zvcm1lcnMub25ueCUyMC0tbW9kZWwlM0RrZXJhcy1pbyUyRnRyYW5zZm9ybWVycy1xYSUyMG9ubnglMkY=",highlighted:"python -m transformers.onnx --model=keras-io/transformers-qa onnx/"}}),ea=new Z1({props:{pytorch:!0,tensorflow:!0,jax:!1,$$slots:{tensorflow:[R1],pytorch:[x1]},$$scope:{ctx:R}}}),st=new q({}),yt=new B({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycy5vbm54LmZlYXR1cmVzJTIwaW1wb3J0JTIwRmVhdHVyZXNNYW5hZ2VyJTBBJTBBZGlzdGlsYmVydF9mZWF0dXJlcyUyMCUzRCUyMGxpc3QoRmVhdHVyZXNNYW5hZ2VyLmdldF9zdXBwb3J0ZWRfZmVhdHVyZXNfZm9yX21vZGVsX3R5cGUoJTIyZGlzdGlsYmVydCUyMikua2V5cygpKSUwQXByaW50KGRpc3RpbGJlcnRfZmVhdHVyZXMp",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>]`}}),vt=new B({props:{code:"cHl0aG9uJTIwLW0lMjB0cmFuc2Zvcm1lcnMub25ueCUyMC0tbW9kZWwlM0RkaXN0aWxiZXJ0LWJhc2UtdW5jYXNlZC1maW5ldHVuZWQtc3N0LTItZW5nbGlzaCUyMCU1QyUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMC0tZmVhdHVyZSUzRHNlcXVlbmNlLWNsYXNzaWZpY2F0aW9uJTIwb25ueCUyRg==",highlighted:`python -m transformers.onnx --model=distilbert-base-uncased-finetuned-sst-2-english \\
                            --feature=sequence-classification onnx/`}}),bt=new B({props:{code:"VmFsaWRhdGluZyUyME9OTlglMjBtb2RlbC4uLiUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMC0lNUIlRTIlOUMlOTMlNUQlMjBPTk5YJTIwbW9kZWwlMjBvdXRwdXQlMjBuYW1lcyUyMG1hdGNoJTIwcmVmZXJlbmNlJTIwbW9kZWwlMjAoJTdCJ2xvZ2l0cyclN0QpJTBBJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwLSUyMFZhbGlkYXRpbmclMjBPTk5YJTIwTW9kZWwlMjBvdXRwdXQlMjAlMjJsb2dpdHMlMjIlM0ElMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAtJTVCJUUyJTlDJTkzJTVEJTIwKDIlMkMlMjAyKSUyMG1hdGNoZXMlMjAoMiUyQyUyMDIpJTBBJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwLSU1QiVFMiU5QyU5MyU1RCUyMGFsbCUyMHZhbHVlcyUyMGNsb3NlJTIwKGF0b2wlM0ElMjAxZS0wNSklMEFBbGwlMjBnb29kJTJDJTIwbW9kZWwlMjBzYXZlZCUyMGF0JTNBJTIwb25ueCUyRm1vZGVsLm9ubng=",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`}}),sa=new no({props:{$$slots:{default:[q1]},$$scope:{ctx:R}}}),Et=new q({}),jt=new q({}),pa=new no({props:{$$slots:{default:[X1]},$$scope:{ctx:R}}}),wt=new B({props:{code:"ZnJvbSUyMHR5cGluZyUyMGltcG9ydCUyME1hcHBpbmclMkMlMjBPcmRlcmVkRGljdCUwQWZyb20lMjB0cmFuc2Zvcm1lcnMub25ueCUyMGltcG9ydCUyME9ubnhDb25maWclMEElMEElMEFjbGFzcyUyMERpc3RpbEJlcnRPbm54Q29uZmlnKE9ubnhDb25maWcpJTNBJTBBJTIwJTIwJTIwJTIwJTQwcHJvcGVydHklMEElMjAlMjAlMjAlMjBkZWYlMjBpbnB1dHMoc2VsZiklMjAtJTNFJTIwTWFwcGluZyU1QnN0ciUyQyUyME1hcHBpbmclNUJpbnQlMkMlMjBzdHIlNUQlNUQlM0ElMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjByZXR1cm4lMjBPcmRlcmVkRGljdCglMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlNUIlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAoJTIyaW5wdXRfaWRzJTIyJTJDJTIwJTdCMCUzQSUyMCUyMmJhdGNoJTIyJTJDJTIwMSUzQSUyMCUyMnNlcXVlbmNlJTIyJTdEKSUyQyUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCglMjJhdHRlbnRpb25fbWFzayUyMiUyQyUyMCU3QjAlM0ElMjAlMjJiYXRjaCUyMiUyQyUyMDElM0ElMjAlMjJzZXF1ZW5jZSUyMiU3RCklMkMlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlNUQlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAp",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 no({props:{$$slots:{default:[z1]},$$scope:{ctx:R}}}),_t=new B({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Db25maWclMEElMEFjb25maWclMjAlM0QlMjBBdXRvQ29uZmlnLmZyb21fcHJldHJhaW5lZCglMjJkaXN0aWxiZXJ0LWJhc2UtdW5jYXNlZCUyMiklMEFvbm54X2NvbmZpZyUyMCUzRCUyMERpc3RpbEJlcnRPbm54Q29uZmlnKGNvbmZpZyk=",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)`}}),gt=new B({props:{code:"cHJpbnQob25ueF9jb25maWcuZGVmYXVsdF9vbm54X29wc2V0KQ==",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>`}}),Tt=new B({props:{code:"cHJpbnQob25ueF9jb25maWcub3V0cHV0cyk=",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>})])`}}),Ut=new B({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Db25maWclMEElMEFjb25maWclMjAlM0QlMjBBdXRvQ29uZmlnLmZyb21fcHJldHJhaW5lZCglMjJkaXN0aWxiZXJ0LWJhc2UtdW5jYXNlZCUyMiklMEFvbm54X2NvbmZpZ19mb3Jfc2VxX2NsZiUyMCUzRCUyMERpc3RpbEJlcnRPbm54Q29uZmlnKGNvbmZpZyUyQyUyMHRhc2slM0QlMjJzZXF1ZW5jZS1jbGFzc2lmaWNhdGlvbiUyMiklMEFwcmludChvbm54X2NvbmZpZ19mb3Jfc2VxX2NsZi5vdXRwdXRzKQ==",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 no({props:{$$slots:{default:[G1]},$$scope:{ctx:R}}}),$t=new q({}),Ct=new B({props:{code:"ZnJvbSUyMHBhdGhsaWIlMjBpbXBvcnQlMjBQYXRoJTBBZnJvbSUyMHRyYW5zZm9ybWVycy5vbm54JTIwaW1wb3J0JTIwZXhwb3J0JTBBZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEF1dG9Ub2tlbml6ZXIlMkMlMjBBdXRvTW9kZWwlMEElMEFvbm54X3BhdGglMjAlM0QlMjBQYXRoKCUyMm1vZGVsLm9ubnglMjIpJTBBbW9kZWxfY2twdCUyMCUzRCUyMCUyMmRpc3RpbGJlcnQtYmFzZS11bmNhc2VkJTIyJTBBYmFzZV9tb2RlbCUyMCUzRCUyMEF1dG9Nb2RlbC5mcm9tX3ByZXRyYWluZWQobW9kZWxfY2twdCklMEF0b2tlbml6ZXIlMjAlM0QlMjBBdXRvVG9rZW5pemVyLmZyb21fcHJldHJhaW5lZChtb2RlbF9ja3B0KSUwQSUwQW9ubnhfaW5wdXRzJTJDJTIwb25ueF9vdXRwdXRzJTIwJTNEJTIwZXhwb3J0KHRva2VuaXplciUyQyUyMGJhc2VfbW9kZWwlMkMlMjBvbm54X2NvbmZpZyUyQyUyMG9ubnhfY29uZmlnLmRlZmF1bHRfb25ueF9vcHNldCUyQyUyMG9ubnhfcGF0aCk=",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)`}}),Jt=new B({props:{code:"aW1wb3J0JTIwb25ueCUwQSUwQW9ubnhfbW9kZWwlMjAlM0QlMjBvbm54LmxvYWQoJTIybW9kZWwub25ueCUyMiklMEFvbm54LmNoZWNrZXIuY2hlY2tfbW9kZWwob25ueF9tb2RlbCk=",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 no({props:{$$slots:{default:[S1]},$$scope:{ctx:R}}}),Nt=new q({}),It=new B({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycy5vbm54JTIwaW1wb3J0JTIwdmFsaWRhdGVfbW9kZWxfb3V0cHV0cyUwQSUwQXZhbGlkYXRlX21vZGVsX291dHB1dHMoJTBBJTIwJTIwJTIwJTIwb25ueF9jb25maWclMkMlMjB0b2tlbml6ZXIlMkMlMjBiYXNlX21vZGVsJTJDJTIwb25ueF9wYXRoJTJDJTIwb25ueF9vdXRwdXRzJTJDJTIwb25ueF9jb25maWcuYXRvbF9mb3JfdmFsaWRhdGlvbiUwQSk=",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>)`}}),kt=new q({}),Bt=new q({}),ja=new no({props:{$$slots:{default:[V1]},$$scope:{ctx:R}}}),Rt=new q({}),qt=new q({}),Xt=new q({}),zt=new q({}),Gt=new B({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEJlcnRNb2RlbCUyQyUyMEJlcnRUb2tlbml6ZXIlMkMlMjBCZXJ0Q29uZmlnJTBBaW1wb3J0JTIwdG9yY2glMEElMEFlbmMlMjAlM0QlMjBCZXJ0VG9rZW5pemVyLmZyb21fcHJldHJhaW5lZCglMjJiZXJ0LWJhc2UtdW5jYXNlZCUyMiklMEElMEElMjMlMjBUb2tlbml6aW5nJTIwaW5wdXQlMjB0ZXh0JTBBdGV4dCUyMCUzRCUyMCUyMiU1QkNMUyU1RCUyMFdobyUyMHdhcyUyMEppbSUyMEhlbnNvbiUyMCUzRiUyMCU1QlNFUCU1RCUyMEppbSUyMEhlbnNvbiUyMHdhcyUyMGElMjBwdXBwZXRlZXIlMjAlNUJTRVAlNUQlMjIlMEF0b2tlbml6ZWRfdGV4dCUyMCUzRCUyMGVuYy50b2tlbml6ZSh0ZXh0KSUwQSUwQSUyMyUyME1hc2tpbmclMjBvbmUlMjBvZiUyMHRoZSUyMGlucHV0JTIwdG9rZW5zJTBBbWFza2VkX2luZGV4JTIwJTNEJTIwOCUwQXRva2VuaXplZF90ZXh0JTVCbWFza2VkX2luZGV4JTVEJTIwJTNEJTIwJTIyJTVCTUFTSyU1RCUyMiUwQWluZGV4ZWRfdG9rZW5zJTIwJTNEJTIwZW5jLmNvbnZlcnRfdG9rZW5zX3RvX2lkcyh0b2tlbml6ZWRfdGV4dCklMEFzZWdtZW50c19pZHMlMjAlM0QlMjAlNUIwJTJDJTIwMCUyQyUyMDAlMkMlMjAwJTJDJTIwMCUyQyUyMDAlMkMlMjAwJTJDJTIwMSUyQyUyMDElMkMlMjAxJTJDJTIwMSUyQyUyMDElMkMlMjAxJTJDJTIwMSU1RCUwQSUwQSUyMyUyMENyZWF0aW5nJTIwYSUyMGR1bW15JTIwaW5wdXQlMEF0b2tlbnNfdGVuc29yJTIwJTNEJTIwdG9yY2gudGVuc29yKCU1QmluZGV4ZWRfdG9rZW5zJTVEKSUwQXNlZ21lbnRzX3RlbnNvcnMlMjAlM0QlMjB0b3JjaC50ZW5zb3IoJTVCc2VnbWVudHNfaWRzJTVEKSUwQWR1bW15X2lucHV0JTIwJTNEJTIwJTVCdG9rZW5zX3RlbnNvciUyQyUyMHNlZ21lbnRzX3RlbnNvcnMlNUQlMEElMEElMjMlMjBJbml0aWFsaXppbmclMjB0aGUlMjBtb2RlbCUyMHdpdGglMjB0aGUlMjB0b3JjaHNjcmlwdCUyMGZsYWclMEElMjMlMjBGbGFnJTIwc2V0JTIwdG8lMjBUcnVlJTIwZXZlbiUyMHRob3VnaCUyMGl0JTIwaXMlMjBub3QlMjBuZWNlc3NhcnklMjBhcyUyMHRoaXMlMjBtb2RlbCUyMGRvZXMlMjBub3QlMjBoYXZlJTIwYW4lMjBMTSUyMEhlYWQuJTBBY29uZmlnJTIwJTNEJTIwQmVydENvbmZpZyglMEElMjAlMjAlMjAlMjB2b2NhYl9zaXplX29yX2NvbmZpZ19qc29uX2ZpbGUlM0QzMjAwMCUyQyUwQSUyMCUyMCUyMCUyMGhpZGRlbl9zaXplJTNENzY4JTJDJTBBJTIwJTIwJTIwJTIwbnVtX2hpZGRlbl9sYXllcnMlM0QxMiUyQyUwQSUyMCUyMCUyMCUyMG51bV9hdHRlbnRpb25faGVhZHMlM0QxMiUyQyUwQSUyMCUyMCUyMCUyMGludGVybWVkaWF0ZV9zaXplJTNEMzA3MiUyQyUwQSUyMCUyMCUyMCUyMHRvcmNoc2NyaXB0JTNEVHJ1ZSUyQyUwQSklMEElMEElMjMlMjBJbnN0YW50aWF0aW5nJTIwdGhlJTIwbW9kZWwlMEFtb2RlbCUyMCUzRCUyMEJlcnRNb2RlbChjb25maWcpJTBBJTBBJTIzJTIwVGhlJTIwbW9kZWwlMjBuZWVkcyUyMHRvJTIwYmUlMjBpbiUyMGV2YWx1YXRpb24lMjBtb2RlJTBBbW9kZWwuZXZhbCgpJTBBJTBBJTIzJTIwSWYlMjB5b3UlMjBhcmUlMjBpbnN0YW50aWF0aW5nJTIwdGhlJTIwbW9kZWwlMjB3aXRoJTIwKmZyb21fcHJldHJhaW5lZColMjB5b3UlMjBjYW4lMjBhbHNvJTIwZWFzaWx5JTIwc2V0JTIwdGhlJTIwVG9yY2hTY3JpcHQlMjBmbGFnJTBBbW9kZWwlMjAlM0QlMjBCZXJ0TW9kZWwuZnJvbV9wcmV0cmFpbmVkKCUyMmJlcnQtYmFzZS11bmNhc2VkJTIyJTJDJTIwdG9yY2hzY3JpcHQlM0RUcnVlKSUwQSUwQSUyMyUyMENyZWF0aW5nJTIwdGhlJTIwdHJhY2UlMEF0cmFjZWRfbW9kZWwlMjAlM0QlMjB0b3JjaC5qaXQudHJhY2UobW9kZWwlMkMlMjAlNUJ0b2tlbnNfdGVuc29yJTJDJTIwc2VnbWVudHNfdGVuc29ycyU1RCklMEF0b3JjaC5qaXQuc2F2ZSh0cmFjZWRfbW9kZWwlMkMlMjAlMjJ0cmFjZWRfYmVydC5wdCUyMik=",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>)`}}),St=new q({}),Vt=new B({props:{code:"bG9hZGVkX21vZGVsJTIwJTNEJTIwdG9yY2guaml0LmxvYWQoJTIydHJhY2VkX2JlcnQucHQlMjIpJTBBbG9hZGVkX21vZGVsLmV2YWwoKSUwQSUwQWFsbF9lbmNvZGVyX2xheWVycyUyQyUyMHBvb2xlZF9vdXRwdXQlMjAlM0QlMjBsb2FkZWRfbW9kZWwoKmR1bW15X2lucHV0KQ==",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)`}}),Ot=new q({}),Pt=new B({props:{code:"dHJhY2VkX21vZGVsKHRva2Vuc190ZW5zb3IlMkMlMjBzZWdtZW50c190ZW5zb3JzKQ==",highlighted:"traced_model(tokens_tensor, segments_tensors)"}}),Dt=new q({}),Kt=new q({}),ll=new q({}),nl=new q({}),il=new B({props:{code:"ZnJvbSUyMHRyYW5zZm9ybWVycyUyMGltcG9ydCUyMEJlcnRNb2RlbCUyQyUyMEJlcnRUb2tlbml6ZXIlMkMlMjBCZXJ0Q29uZmlnJTBBaW1wb3J0JTIwdG9yY2glMEFpbXBvcnQlMjB0b3JjaC5uZXVyb24=",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`}}),cl=new B({props:{code:"dG9yY2guaml0LnRyYWNlKG1vZGVsJTJDJTIwJTVCdG9rZW5zX3RlbnNvciUyQyUyMHNlZ21lbnRzX3RlbnNvcnMlNUQp",highlighted:"torch.jit.trace(model, [tokens_tensor, segments_tensors])"}}),dl=new B({props:{code:"dG9yY2gubmV1cm9uLnRyYWNlKG1vZGVsJTJDJTIwJTVCdG9rZW5fdGVuc29yJTJDJTIwc2VnbWVudHNfdGVuc29ycyU1RCk=",highlighted:"torch.neuron.trace(model, [token_tensor, segments_tensors])"}}),{c(){m=s("meta"),T=d(),M=s("h1"),g=s("a"),$=s("span"),v(U.$$.fragment),k=d(),N=s("span"),I=l("Exportar modelos \u{1F917} Transformers"),A=d(),x=s("p"),J=l(`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.`),Z=d(),y=s("p"),C=l(`Una vez exportado, un modelo puede optimizarse para la inferencia a trav\xE9s de t\xE9cnicas
como la cuantizaci\xF3n y `),X=s("em"),F=l("pruning"),Ee=l(`. Si est\xE1s interesado en optimizar tus modelos para
que funcionen con la m\xE1xima eficiencia, consulta la
`),se=s("a"),Va=l("biblioteca de \u{1F917} Optimum"),je=l("."),Pe=d(),Q=s("h2"),O=s("a"),W=s("span"),v(ne.$$.fragment),ml=d(),De=s("span"),fl=l("ONNX"),Oa=d(),V=s("p"),hl=l("El proyecto "),Pa=s("a"),Fd=l("ONNX (Open Neural Network eXchange)"),Qd=l(` 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 `),ro=s("em"),Hd=l("frameworks"),Yd=l(`, incluidos PyTorch y TensorFlow. Cuando un modelo
se exporta al formato ONNX, estos operadores se usan para construir un
grafo computacional (a menudo llamado `),io=s("em"),Kd=l("representaci\xF3n intermedia"),ep=l(`) que
representa el flujo de datos a trav\xE9s de la red neuronal.`),Vr=d(),Ml=s("p"),ap=l(`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).`),Or=d(),Le=s("p"),tp=l("\u{1F917} Transformers proporciona un paquete llamado "),co=s("code"),lp=l("transformers.onnx"),op=l(`, 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.`),Pr=d(),yl=s("p"),sp=l("Las configuraciones a la medida incluyen las siguientes arquitecturas:"),Dr=d(),f=s("ul"),po=s("li"),np=l("ALBERT"),rp=d(),uo=s("li"),ip=l("BART"),cp=d(),mo=s("li"),dp=l("BEiT"),pp=d(),fo=s("li"),up=l("BERT"),mp=d(),ho=s("li"),fp=l("BigBird"),hp=d(),Mo=s("li"),Mp=l("BigBird-Pegasus"),yp=d(),yo=s("li"),vp=l("Blenderbot"),bp=d(),vo=s("li"),Ep=l("BlenderbotSmall"),jp=d(),bo=s("li"),wp=l("BLOOM"),_p=d(),Eo=s("li"),gp=l("CamemBERT"),Tp=d(),jo=s("li"),Up=l("CLIP"),$p=d(),wo=s("li"),Cp=l("CodeGen"),Jp=d(),_o=s("li"),Np=l("ConvBERT"),Ip=d(),go=s("li"),kp=l("ConvNeXT"),Ap=d(),To=s("li"),Zp=l("ConvNeXTV2"),Bp=d(),Uo=s("li"),xp=l("Data2VecText"),Wp=d(),$o=s("li"),Rp=l("Data2VecVision"),qp=d(),Co=s("li"),Xp=l("DeBERTa"),zp=d(),Jo=s("li"),Gp=l("DeBERTa-v2"),Sp=d(),No=s("li"),Vp=l("DeiT"),Op=d(),Io=s("li"),Pp=l("DETR"),Dp=d(),ko=s("li"),Lp=l("DistilBERT"),Fp=d(),Ao=s("li"),Qp=l("ELECTRA"),Hp=d(),Zo=s("li"),Yp=l("FlauBERT"),Kp=d(),Bo=s("li"),eu=l("GPT Neo"),au=d(),xo=s("li"),tu=l("GPT-J"),lu=d(),Wo=s("li"),ou=l("I-BERT"),su=d(),Ro=s("li"),nu=l("LayoutLM"),ru=d(),qo=s("li"),iu=l("LayoutLMv3"),cu=d(),Xo=s("li"),du=l("LeViT"),pu=d(),zo=s("li"),uu=l("LongT5"),mu=d(),Go=s("li"),fu=l("M2M100"),hu=d(),So=s("li"),Mu=l("Marian"),yu=d(),Vo=s("li"),vu=l("mBART"),bu=d(),Oo=s("li"),Eu=l("MobileBERT"),ju=d(),Po=s("li"),wu=l("MobileViT"),_u=d(),Do=s("li"),gu=l("MT5"),Tu=d(),Lo=s("li"),Uu=l("OpenAI GPT-2"),$u=d(),Fo=s("li"),Cu=l("Perceiver"),Ju=d(),Qo=s("li"),Nu=l("PLBart"),Iu=d(),Ho=s("li"),ku=l("ResNet"),Au=d(),Yo=s("li"),Zu=l("RoBERTa"),Bu=d(),Ko=s("li"),xu=l("RoFormer"),Wu=d(),es=s("li"),Ru=l("SqueezeBERT"),qu=d(),as=s("li"),Xu=l("T5"),zu=d(),ts=s("li"),Gu=l("ViT"),Su=d(),ls=s("li"),Vu=l("XLM"),Ou=d(),os=s("li"),Pu=l("XLM-RoBERTa"),Du=d(),ss=s("li"),Lu=l("XLM-RoBERTa-XL"),Fu=d(),ns=s("li"),Qu=l("YOLOS"),Lr=d(),vl=s("p"),Hu=l("En las pr\xF3ximas dos secciones, te mostraremos c\xF3mo:"),Fr=d(),Fe=s("ul"),Da=s("li"),Yu=l("Exportar un modelo compatible utilizando el paquete "),rs=s("code"),Ku=l("transformers.onnx"),em=l("."),am=d(),is=s("li"),tm=l("Exportar un modelo personalizado para una arquitectura no compatible."),Qr=d(),we=s("h3"),Qe=s("a"),cs=s("span"),v(La.$$.fragment),lm=d(),ds=s("span"),om=l("Exportar un model a ONNX"),Hr=d(),bl=s("p"),sm=l(`Para exportar un modelo \u{1F917} Transformers a ONNX, tienes que instalar primero algunas
dependencias extra:`),Yr=d(),v(Fa.$$.fragment),Kr=d(),He=s("p"),nm=l("El paquete "),ps=s("code"),rm=l("transformers.onnx"),im=l(" puede ser usado luego como un m\xF3dulo de Python:"),ei=d(),v(Qa.$$.fragment),ai=d(),El=s("p"),cm=l("Exportar un checkpoint usando una configuraci\xF3n a la medida se puede hacer de la siguiente manera:"),ti=d(),v(Ha.$$.fragment),li=d(),jl=s("p"),dm=l("que deber\xEDa mostrar los siguientes registros:"),oi=d(),v(Ya.$$.fragment),si=d(),re=s("p"),pm=l("Esto exporta un grafo ONNX del checkpoint definido por el argumento "),us=s("code"),um=l("--model"),mm=l(`.
En este ejemplo, es un modelo `),ms=s("code"),fm=l("distilbert-base-uncased"),hm=l(`, pero puede ser cualquier
checkpoint en Hugging Face Hub o que est\xE9 almacenado localmente.`),ni=d(),Y=s("p"),Mm=l("El archivo "),fs=s("code"),ym=l("model.onnx"),vm=l(` resultante se puede ejecutar en uno de los
`),Ka=s("a"),bm=l("muchos aceleradores"),Em=l(`
que admiten el est\xE1ndar ONNX. Por ejemplo, podemos cargar y ejecutar el
modelo con `),et=s("a"),jm=l("ONNX Runtime"),wm=l(" de la siguiente manera:"),ri=d(),v(at.$$.fragment),ii=d(),Ye=s("p"),_m=l("Los nombres necesarios de salida (es decir, "),hs=s("code"),gm=l('["last_hidden_state"]'),Tm=l(`) se pueden obtener
echando un vistazo a la configuraci\xF3n ONNX de cada modelo. Por ejemplo, para DistilBERT tenemos:`),ci=d(),v(tt.$$.fragment),di=d(),Ke=s("p"),Um=l(`El proceso es id\xE9ntico para los checkpoints de TensorFlow en Hub.
Por ejemplo, podemos exportar un checkpoint puro de TensorFlow desde
`),lt=s("a"),$m=l("Keras"),Cm=l(" de la siguiente manera:"),pi=d(),v(ot.$$.fragment),ui=d(),wl=s("p"),Jm=l(`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=d(),v(ea.$$.fragment),fi=d(),_e=s("h3"),aa=s("a"),Ms=s("span"),v(st.$$.fragment),Nm=d(),ys=s("span"),Im=l("Seleccionar caracter\xEDsticas para diferentes topolog\xEDas de un modelo"),hi=d(),ta=s("p"),km=l("Cada configuraci\xF3n a la medida viene con un conjunto de "),vs=s("em"),Am=l("caracter\xEDsticas"),Zm=l(` 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:`),Mi=d(),la=s("table"),bs=s("thead"),nt=s("tr"),Es=s("th"),Bm=l("Feature"),xm=d(),js=s("th"),Wm=l("Auto Class"),Rm=d(),z=s("tbody"),rt=s("tr"),it=s("td"),ws=s("code"),qm=l("causal-lm"),Xm=l(", "),_s=s("code"),zm=l("causal-lm-with-past"),Gm=d(),gs=s("td"),Ts=s("code"),Sm=l("AutoModelForCausalLM"),Vm=d(),ct=s("tr"),dt=s("td"),Us=s("code"),Om=l("default"),Pm=l(", "),$s=s("code"),Dm=l("default-with-past"),Lm=d(),Cs=s("td"),Js=s("code"),Fm=l("AutoModel"),Qm=d(),pt=s("tr"),Ns=s("td"),Is=s("code"),Hm=l("masked-lm"),Ym=d(),ks=s("td"),As=s("code"),Km=l("AutoModelForMaskedLM"),ef=d(),ut=s("tr"),Zs=s("td"),Bs=s("code"),af=l("question-answering"),tf=d(),xs=s("td"),Ws=s("code"),lf=l("AutoModelForQuestionAnswering"),of=d(),mt=s("tr"),ft=s("td"),Rs=s("code"),sf=l("seq2seq-lm"),nf=l(", "),qs=s("code"),rf=l("seq2seq-lm-with-past"),cf=d(),Xs=s("td"),zs=s("code"),df=l("AutoModelForSeq2SeqLM"),pf=d(),ht=s("tr"),Gs=s("td"),Ss=s("code"),uf=l("sequence-classification"),mf=d(),Vs=s("td"),Os=s("code"),ff=l("AutoModelForSequenceClassification"),hf=d(),Mt=s("tr"),Ps=s("td"),Ds=s("code"),Mf=l("token-classification"),yf=d(),Ls=s("td"),Fs=s("code"),vf=l("AutoModelForTokenClassification"),yi=d(),oa=s("p"),bf=l("Para cada configuraci\xF3n, puedes encontrar la lista de funciones admitidas a trav\xE9s de "),Qs=s("code"),Ef=l("FeaturesManager"),jf=l(`.
Por ejemplo, para DistilBERT tenemos:`),vi=d(),v(yt.$$.fragment),bi=d(),ie=s("p"),wf=l("Le puedes pasar una de estas caracter\xEDsticas al argumento "),Hs=s("code"),_f=l("--feature"),gf=l(" en el paquete "),Ys=s("code"),Tf=l("transformers.onnx"),Uf=l(`.
Por ejemplo, para exportar un modelo de clasificaci\xF3n de texto, podemos elegir un modelo ya ajustado del Hub y ejecutar:`),Ei=d(),v(vt.$$.fragment),ji=d(),_l=s("p"),$f=l("que mostrar\xE1 los siguientes registros:"),wi=d(),v(bt.$$.fragment),_i=d(),K=s("p"),Cf=l("Ten en cuenta que, en este caso, los nombres de salida del modelo ajustado son "),Ks=s("code"),Jf=l("logits"),Nf=l(" en lugar de "),en=s("code"),If=l("last_hidden_state"),kf=l(`
que vimos anteriormente con el checkpoint `),an=s("code"),Af=l("distilbert-base-uncased"),Zf=l(`. Esto es de esperarse ya que el modelo ajustado
tiene un cabezal de clasificaci\xF3n secuencial.`),gi=d(),v(sa.$$.fragment),Ti=d(),ge=s("h3"),na=s("a"),tn=s("span"),v(Et.$$.fragment),Bf=d(),ln=s("span"),xf=l("Exportar un modelo para una arquitectura no compatible"),Ui=d(),gl=s("p"),Wf=l(`Si deseas exportar un modelo cuya arquitectura no es compatible de forma nativa
con la biblioteca, debes seguir tres pasos principales:`),$i=d(),ce=s("ol"),on=s("li"),Rf=l("Implementa una configuraci\xF3n personalizada en ONNX."),qf=d(),sn=s("li"),Xf=l("Exporta el modelo a ONNX."),zf=d(),nn=s("li"),Gf=l("Valide los resultados de PyTorch y los modelos exportados."),Ci=d(),Tl=s("p"),Sf=l(`En esta secci\xF3n, veremos c\xF3mo se implement\xF3 la serializaci\xF3n de DistilBERT
para mostrar lo que implica cada paso.`),Ji=d(),Te=s("h4"),ra=s("a"),rn=s("span"),v(jt.$$.fragment),Vf=d(),cn=s("span"),Of=l("Implementar una configuraci\xF3n personalizada en ONNX"),Ni=d(),Ul=s("p"),Pf=l(`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:`),Ii=d(),de=s("ul"),ia=s("li"),Df=l("Modelos basados en el "),dn=s("em"),Lf=l("Encoder"),Ff=l(" inherente de "),pn=s("code"),Qf=l("OnnxConfig"),Hf=d(),ca=s("li"),Yf=l("Modelos basados en el "),un=s("em"),Kf=l("Decoder"),eh=l(" inherente de "),mn=s("code"),ah=l("OnnxConfigWithPast"),th=d(),da=s("li"),lh=l("Modelos "),fn=s("em"),oh=l("Encoder-decoder"),sh=l(" inherente de "),hn=s("code"),nh=l("OnnxSeq2SeqConfigWithPast"),ki=d(),v(pa.$$.fragment),Ai=d(),pe=s("p"),rh=l("Dado que DistilBERT es un modelo de tipo "),Mn=s("em"),ih=l("encoder"),ch=l(", su configuraci\xF3n se hereda de "),yn=s("code"),dh=l("OnnxConfig"),ph=l(":"),Zi=d(),v(wt.$$.fragment),Bi=d(),P=s("p"),uh=l("Cada objeto de configuraci\xF3n debe implementar la propiedad "),vn=s("code"),mh=l("inputs"),fh=l(` 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: `),bn=s("code"),hh=l("input_ids"),Mh=l(" y "),En=s("code"),yh=l("attention_mask"),vh=l(`.
Estas entradas tienen la misma forma de `),jn=s("code"),bh=l("(batch_size, sequence_length)"),Eh=l(`, es por lo que vemos
los mismos ejes utilizados en la configuraci\xF3n.`),xi=d(),v(ua.$$.fragment),Wi=d(),$l=s("p"),jh=l(`Una vez que hayas implementado una configuraci\xF3n ONNX, puedes crear una
instancia proporcionando la configuraci\xF3n del modelo base de la siguiente manera:`),Ri=d(),v(_t.$$.fragment),qi=d(),Cl=s("p"),wh=l(`El objeto resultante tiene varias propiedades \xFAtiles. Por ejemplo, puedes ver el conjunto de operadores ONNX que se
utilizar\xE1 durante la exportaci\xF3n:`),Xi=d(),v(gt.$$.fragment),zi=d(),Jl=s("p"),_h=l("Tambi\xE9n puedes ver los resultados asociados con el modelo de la siguiente manera:"),Gi=d(),v(Tt.$$.fragment),Si=d(),D=s("p"),gh=l(`Observa que la propiedad de salidas sigue la misma estructura que las entradas;
devuelve un objecto `),wn=s("code"),Th=l("OrderedDict"),Uh=l(` 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 `),_n=s("code"),$h=l("default"),Ch=l(` que
corresponde a exportar un modelo cargado con la clase `),gn=s("code"),Jh=l("AutoModel"),Nh=l(`. Si quieres exportar
una topolog\xEDa de modelo diferente, simplemente proporciona una caracter\xEDstica diferente
al argumento `),Tn=s("code"),Ih=l("task"),kh=l(` 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:`),Vi=d(),v(Ut.$$.fragment),Oi=d(),v(ma.$$.fragment),Pi=d(),Ue=s("h4"),fa=s("a"),Un=s("span"),v($t.$$.fragment),Ah=d(),$n=s("span"),Zh=l("Exportar el modelo"),Di=d(),ue=s("p"),Bh=l(`Una vez que hayas implementado la configuraci\xF3n de ONNX, el siguiente paso es exportar el modelo.
Aqu\xED podemos usar la funci\xF3n `),Cn=s("code"),xh=l("export()"),Wh=l(" proporcionada por el paquete "),Jn=s("code"),Rh=l("transformers.onnx"),qh=l(`.
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:`),Li=d(),v(Ct.$$.fragment),Fi=d(),G=s("p"),Xh=l("Los objetos "),Nn=s("code"),zh=l("onnx_inputs"),Gh=l(" y "),In=s("code"),Sh=l("onnx_outputs"),Vh=l(" devueltos por la funci\xF3n "),kn=s("code"),Oh=l("export()"),Ph=l(`
son listas de llaves definidas en las propiedades `),An=s("code"),Dh=l("inputs"),Lh=l(" y "),Zn=s("code"),Fh=l("outputs"),Qh=l(` de la configuraci\xF3n.
Una vez exportado el modelo, puedes probar que el modelo est\xE1 bien formado de la siguiente manera:`),Qi=d(),v(Jt.$$.fragment),Hi=d(),v(ha.$$.fragment),Yi=d(),$e=s("h4"),Ma=s("a"),Bn=s("span"),v(Nt.$$.fragment),Hh=d(),xn=s("span"),Yh=l("Validar los resultados del modelo"),Ki=d(),me=s("p"),Kh=l(`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 `),Wn=s("code"),eM=l("validate_model_outputs()"),aM=l(`
proporcionada por el paquete `),Rn=s("code"),tM=l("transformers.onnx"),lM=l(" de la siguiente manera:"),ec=d(),v(It.$$.fragment),ac=d(),ya=s("p"),oM=l("Esta funci\xF3n usa el m\xE9todo "),qn=s("code"),sM=l("OnnxConfig.generate_dummy_inputs()"),nM=l(` 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.`),tc=d(),Ce=s("h3"),va=s("a"),Xn=s("span"),v(kt.$$.fragment),rM=d(),zn=s("span"),iM=l("Contribuir con una nueva configuraci\xF3n a \u{1F917} Transformers"),lc=d(),Nl=s("p"),cM=l(`\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:`),oc=d(),fe=s("ul"),At=s("li"),dM=l("Implementa la configuraci\xF3n de ONNX en el archivo "),Gn=s("code"),pM=l("configuration_<model_name>.py"),uM=l(" correspondiente"),mM=d(),Il=s("li"),fM=l("Incluye la arquitectura del modelo y las caracter\xEDsticas correspondientes en "),Sn=s("code"),hM=l("~onnx.features.FeatureManager"),MM=d(),kl=s("li"),yM=l("Agrega tu arquitectura de modelo a las pruebas en "),Vn=s("code"),vM=l("test_onnx_v2.py"),sc=d(),ba=s("p"),bM=l("Revisa c\xF3mo fue la contribuci\xF3n para la "),Zt=s("a"),EM=l("configuraci\xF3n de IBERT"),jM=l(`
y as\xED tener una idea de lo que necesito.`),nc=d(),Je=s("h2"),Ea=s("a"),On=s("span"),v(Bt.$$.fragment),wM=d(),Pn=s("span"),_M=l("TorchScript"),rc=d(),v(ja.$$.fragment),ic=d(),wa=s("p"),gM=l(`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 `),xt=s("a"),TM=l("JIT y TRACE"),UM=l(` permiten al
desarrollador exportar su modelo para reutilizarlo  en otros programas, como los programas C++ orientados a la eficiencia.`),cc=d(),Al=s("p"),$M=l(`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.`),dc=d(),Zl=s("p"),CM=l("Exportar un modelo requiere de dos cosas:"),pc=d(),_a=s("ul"),Dn=s("li"),JM=l("un pase hacia adelante con entradas ficticias."),NM=d(),Wt=s("li"),IM=l("instanciaci\xF3n del modelo con la indicador "),Ln=s("code"),kM=l("torchscript"),AM=l("."),uc=d(),Bl=s("p"),ZM=l("Estas necesidades implican varias cosas con las que los desarrolladores deben tener cuidado. \xC9stas se detallan a continuaci\xF3n."),mc=d(),Ne=s("h3"),ga=s("a"),Fn=s("span"),v(Rt.$$.fragment),BM=d(),Qn=s("span"),xM=l("Indicador de TorchScript y pesos atados"),fc=d(),he=s("p"),WM=l(`Este indicador es necesario porque la mayor\xEDa de los modelos de lenguaje en este repositorio tienen pesos vinculados entre su capa
de `),Hn=s("code"),RM=l("Embedding"),qM=l(" y su capa de "),Yn=s("code"),XM=l("Decoding"),zM=l(`. TorchScript no permite la exportaci\xF3n de modelos que tengan pesos atados, por lo que es
necesario desvincular y clonar los pesos previamente.`),hc=d(),ee=s("p"),GM=l("Esto implica que los modelos instanciados con el indicador "),Kn=s("code"),SM=l("torchscript"),VM=l(" tienen su capa "),er=s("code"),OM=l("Embedding"),PM=l(" y "),ar=s("code"),DM=l("Decoding"),LM=l(` separadas,
lo que significa que no deben entrenarse m\xE1s adelante. El entrenamiento desincronizar\xEDa las dos capas, lo que generar\xEDa
resultados inesperados.`),Mc=d(),Ta=s("p"),FM=l(`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 `),tr=s("code"),QM=l("torchscript"),HM=l("."),yc=d(),Ie=s("h3"),Ua=s("a"),lr=s("span"),v(qt.$$.fragment),YM=d(),or=s("span"),KM=l("Entradas ficticias y longitudes est\xE1ndar"),vc=d(),xl=s("p"),ey=l(`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.`),bc=d(),Wl=s("p"),ay=l(`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:`),Ec=d(),Rl=s("p"),sr=s("code"),ty=l("The expanded size of the tensor (3) must match the existing size (7) at non-singleton dimension 2"),jc=d(),$a=s("p"),ly=l(`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 `),nr=s("em"),oy=l("padding"),sy=l(` 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.`),wc=d(),ql=s("p"),ny=l(`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.`),_c=d(),ke=s("h3"),Ca=s("a"),rr=s("span"),v(Xt.$$.fragment),ry=d(),ir=s("span"),iy=l("Usar TorchScript en Python"),gc=d(),Xl=s("p"),cy=l("A continuaci\xF3n se muestra un ejemplo que muestra c\xF3mo guardar, cargar modelos y c\xF3mo usar el rastreo para la inferencia."),Tc=d(),Ae=s("h4"),Ja=s("a"),cr=s("span"),v(zt.$$.fragment),dy=d(),dr=s("span"),py=l("Guardando un modelo"),Uc=d(),H=s("p"),uy=l("Este fragmento muestra c\xF3mo usar TorchScript para exportar un "),pr=s("code"),my=l("BertModel"),fy=l(". Aqu\xED, el "),ur=s("code"),hy=l("BertModel"),My=l(` se instancia de acuerdo
con la clase `),mr=s("code"),yy=l("BertConfig"),vy=l(" y luego se guarda en el disco con el nombre de archivo "),fr=s("code"),by=l("traced_bert.pt"),$c=d(),v(Gt.$$.fragment),Cc=d(),Ze=s("h4"),Na=s("a"),hr=s("span"),v(St.$$.fragment),Ey=d(),Mr=s("span"),jy=l("Cargar un modelo"),Jc=d(),ae=s("p"),wy=l("Este fragmento muestra c\xF3mo cargar el "),yr=s("code"),_y=l("BertModel"),gy=l(" que se guard\xF3 previamente en el disco con el nombre "),vr=s("code"),Ty=l("traced_bert.pt"),Uy=l(`.
Estamos reutilizando el `),br=s("code"),$y=l("dummy_input"),Cy=l(" previamente inicializado."),Nc=d(),v(Vt.$$.fragment),Ic=d(),Be=s("h4"),Ia=s("a"),Er=s("span"),v(Ot.$$.fragment),Jy=d(),jr=s("span"),Ny=l("Usar un modelo rastreado para la inferencia"),kc=d(),ka=s("p"),Iy=l("Usar el modelo rastreado para la inferencia es tan simple como usar su m\xE9todo "),wr=s("code"),ky=l("__call__"),Ay=l(":"),Ac=d(),v(Pt.$$.fragment),Zc=d(),xe=s("h3"),Aa=s("a"),_r=s("span"),v(Dt.$$.fragment),Zy=d(),gr=s("span"),By=l("Implementar los modelos HuggingFace TorchScript en AWS mediante Neuron SDK"),Bc=d(),Me=s("p"),xy=l("AWS present\xF3 la familia de instancias "),Lt=s("a"),Wy=l("Amazon EC2 Inf1"),Ry=l(` 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. `),Ft=s("a"),qy=l("AWS Neuron"),Xy=l(` 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:`),xc=d(),ye=s("ol"),Tr=s("li"),zy=l("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."),Gy=d(),zl=s("li"),Sy=l("Optimizaciones de rendimiento listas para usar con un "),Qt=s("a"),Vy=l("costo-rendimiento mejorado"),Oy=d(),We=s("li"),Py=l("Soporte para modelos HuggingFace Transformers construidos con "),Ht=s("a"),Dy=l("PyTorch"),Ly=l(`
o `),Yt=s("a"),Fy=l("TensorFlow"),Qy=l("."),Wc=d(),Re=s("h4"),Za=s("a"),Ur=s("span"),v(Kt.$$.fragment),Hy=d(),$r=s("span"),Yy=l("Implicaciones"),Rc=d(),S=s("p"),Ky=l(`Los modelos Transformers basados en la arquitectura
`),qe=s("a"),ev=l("BERT (Representaciones de "),Cr=s("em"),av=l("Enconder"),tv=l(" bidireccional de Transformers)"),lv=l(`,
o sus variantes, como `),el=s("a"),ov=l("distilBERT"),sv=l(` y
`),al=s("a"),nv=l("roBERTa"),rv=l(`, 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
`),tl=s("a"),iv=l("tutorial de AWS Neuron MarianMT"),cv=l(`.
Puedes encontrar m\xE1s informaci\xF3n sobre los modelos que est\xE1n listos para usarse en Inferentia en la
`),Xe=s("a"),dv=l("secci\xF3n "),Jr=s("em"),pv=l("Model Architecture Fit"),uv=l(" de la documentaci\xF3n de Neuron"),mv=l("."),qc=d(),ze=s("h4"),Ba=s("a"),Nr=s("span"),v(ll.$$.fragment),fv=d(),Ir=s("span"),hv=l("Dependencias"),Xc=d(),Gl=s("p"),Mv=l("Usar AWS Neuron para convertir modelos requiere las siguientes dependencias y entornos:"),zc=d(),Sl=s("ul"),Ge=s("li"),yv=l("Un "),ol=s("a"),vv=l("entorno Neuron SDK"),bv=l(`,
que viene preconfigurado en `),sl=s("a"),Ev=l("AWS Deep Learning AMI"),jv=l("."),Gc=d(),Se=s("h4"),xa=s("a"),kr=s("span"),v(nl.$$.fragment),wv=d(),Ar=s("span"),_v=l("Convertir un modelo a AWS Neuron"),Sc=d(),te=s("p"),gv=l("Con el mismo script usado en "),rl=s("a"),Tv=l("Uso de TorchScript en Python"),Uv=l(`
para rastrear un \u201CBertModel\u201D, puedes importar la extensi\xF3n del `),Zr=s("em"),$v=l("framework"),Cv=d(),Br=s("code"),Jv=l("torch.neuron"),Nv=l(` para acceder a los componentes
del SDK de Neuron a trav\xE9s de una API de Python.`),Vc=d(),v(il.$$.fragment),Oc=d(),Vl=s("p"),Iv=l("Y modificando la l\xEDnea de c\xF3digo de rastreo de:"),Pc=d(),v(cl.$$.fragment),Dc=d(),Ol=s("p"),kv=l("con lo siguiente:"),Lc=d(),v(dl.$$.fragment),Fc=d(),Pl=s("p"),Av=l("Este cambio permite a Neuron SDK rastrear el modelo y optimizarlo para ejecutarse en instancias Inf1."),Qc=d(),Wa=s("p"),Zv=l(`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 `),pl=s("a"),Bv=l("documentaci\xF3n de AWS NeuronSDK"),xv=l("."),this.h()},l(e){const i=k1('[data-svelte="svelte-1phssyn"]',document.head);m=n(i,"META",{name:!0,content:!0}),i.forEach(t),T=p(e),M=n(e,"H1",{class:!0});var ul=r(M);g=n(ul,"A",{id:!0,class:!0,href:!0});var xr=r(g);$=n(xr,"SPAN",{});var Wr=r($);b(U.$$.fragment,Wr),Wr.forEach(t),xr.forEach(t),k=p(ul),N=n(ul,"SPAN",{});var Rr=r(N);I=o(Rr,"Exportar modelos \u{1F917} Transformers"),Rr.forEach(t),ul.forEach(t),A=p(e),x=n(e,"P",{});var qr=r(x);J=o(qr,`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.`),qr.forEach(t),Z=p(e),y=n(e,"P",{});var Ve=r(y);C=o(Ve,`Una vez exportado, un modelo puede optimizarse para la inferencia a trav\xE9s de t\xE9cnicas
como la cuantizaci\xF3n y `),X=n(Ve,"EM",{});var Xr=r(X);F=o(Xr,"pruning"),Xr.forEach(t),Ee=o(Ve,`. Si est\xE1s interesado en optimizar tus modelos para
que funcionen con la m\xE1xima eficiencia, consulta la
`),se=n(Ve,"A",{href:!0,rel:!0});var Xv=r(se);Va=o(Xv,"biblioteca de \u{1F917} Optimum"),Xv.forEach(t),je=o(Ve,"."),Ve.forEach(t),Pe=p(e),Q=n(e,"H2",{class:!0});var Yc=r(Q);O=n(Yc,"A",{id:!0,class:!0,href:!0});var zv=r(O);W=n(zv,"SPAN",{});var Gv=r(W);b(ne.$$.fragment,Gv),Gv.forEach(t),zv.forEach(t),ml=p(Yc),De=n(Yc,"SPAN",{});var Sv=r(De);fl=o(Sv,"ONNX"),Sv.forEach(t),Yc.forEach(t),Oa=p(e),V=n(e,"P",{});var Ra=r(V);hl=o(Ra,"El proyecto "),Pa=n(Ra,"A",{href:!0,rel:!0});var Vv=r(Pa);Fd=o(Vv,"ONNX (Open Neural Network eXchange)"),Vv.forEach(t),Qd=o(Ra,` 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 `),ro=n(Ra,"EM",{});var Ov=r(ro);Hd=o(Ov,"frameworks"),Ov.forEach(t),Yd=o(Ra,`, incluidos PyTorch y TensorFlow. Cuando un modelo
se exporta al formato ONNX, estos operadores se usan para construir un
grafo computacional (a menudo llamado `),io=n(Ra,"EM",{});var Pv=r(io);Kd=o(Pv,"representaci\xF3n intermedia"),Pv.forEach(t),ep=o(Ra,`) que
representa el flujo de datos a trav\xE9s de la red neuronal.`),Ra.forEach(t),Vr=p(e),Ml=n(e,"P",{});var Dv=r(Ml);ap=o(Dv,`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).`),Dv.forEach(t),Or=p(e),Le=n(e,"P",{});var Kc=r(Le);tp=o(Kc,"\u{1F917} Transformers proporciona un paquete llamado "),co=n(Kc,"CODE",{});var Lv=r(co);lp=o(Lv,"transformers.onnx"),Lv.forEach(t),op=o(Kc,`, 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.`),Kc.forEach(t),Pr=p(e),yl=n(e,"P",{});var Fv=r(yl);sp=o(Fv,"Las configuraciones a la medida incluyen las siguientes arquitecturas:"),Fv.forEach(t),Dr=p(e),f=n(e,"UL",{});var h=r(f);po=n(h,"LI",{});var Qv=r(po);np=o(Qv,"ALBERT"),Qv.forEach(t),rp=p(h),uo=n(h,"LI",{});var Hv=r(uo);ip=o(Hv,"BART"),Hv.forEach(t),cp=p(h),mo=n(h,"LI",{});var Yv=r(mo);dp=o(Yv,"BEiT"),Yv.forEach(t),pp=p(h),fo=n(h,"LI",{});var Kv=r(fo);up=o(Kv,"BERT"),Kv.forEach(t),mp=p(h),ho=n(h,"LI",{});var eb=r(ho);fp=o(eb,"BigBird"),eb.forEach(t),hp=p(h),Mo=n(h,"LI",{});var ab=r(Mo);Mp=o(ab,"BigBird-Pegasus"),ab.forEach(t),yp=p(h),yo=n(h,"LI",{});var tb=r(yo);vp=o(tb,"Blenderbot"),tb.forEach(t),bp=p(h),vo=n(h,"LI",{});var lb=r(vo);Ep=o(lb,"BlenderbotSmall"),lb.forEach(t),jp=p(h),bo=n(h,"LI",{});var ob=r(bo);wp=o(ob,"BLOOM"),ob.forEach(t),_p=p(h),Eo=n(h,"LI",{});var sb=r(Eo);gp=o(sb,"CamemBERT"),sb.forEach(t),Tp=p(h),jo=n(h,"LI",{});var nb=r(jo);Up=o(nb,"CLIP"),nb.forEach(t),$p=p(h),wo=n(h,"LI",{});var rb=r(wo);Cp=o(rb,"CodeGen"),rb.forEach(t),Jp=p(h),_o=n(h,"LI",{});var ib=r(_o);Np=o(ib,"ConvBERT"),ib.forEach(t),Ip=p(h),go=n(h,"LI",{});var cb=r(go);kp=o(cb,"ConvNeXT"),cb.forEach(t),Ap=p(h),To=n(h,"LI",{});var db=r(To);Zp=o(db,"ConvNeXTV2"),db.forEach(t),Bp=p(h),Uo=n(h,"LI",{});var pb=r(Uo);xp=o(pb,"Data2VecText"),pb.forEach(t),Wp=p(h),$o=n(h,"LI",{});var ub=r($o);Rp=o(ub,"Data2VecVision"),ub.forEach(t),qp=p(h),Co=n(h,"LI",{});var mb=r(Co);Xp=o(mb,"DeBERTa"),mb.forEach(t),zp=p(h),Jo=n(h,"LI",{});var fb=r(Jo);Gp=o(fb,"DeBERTa-v2"),fb.forEach(t),Sp=p(h),No=n(h,"LI",{});var hb=r(No);Vp=o(hb,"DeiT"),hb.forEach(t),Op=p(h),Io=n(h,"LI",{});var Mb=r(Io);Pp=o(Mb,"DETR"),Mb.forEach(t),Dp=p(h),ko=n(h,"LI",{});var yb=r(ko);Lp=o(yb,"DistilBERT"),yb.forEach(t),Fp=p(h),Ao=n(h,"LI",{});var vb=r(Ao);Qp=o(vb,"ELECTRA"),vb.forEach(t),Hp=p(h),Zo=n(h,"LI",{});var bb=r(Zo);Yp=o(bb,"FlauBERT"),bb.forEach(t),Kp=p(h),Bo=n(h,"LI",{});var Eb=r(Bo);eu=o(Eb,"GPT Neo"),Eb.forEach(t),au=p(h),xo=n(h,"LI",{});var jb=r(xo);tu=o(jb,"GPT-J"),jb.forEach(t),lu=p(h),Wo=n(h,"LI",{});var wb=r(Wo);ou=o(wb,"I-BERT"),wb.forEach(t),su=p(h),Ro=n(h,"LI",{});var _b=r(Ro);nu=o(_b,"LayoutLM"),_b.forEach(t),ru=p(h),qo=n(h,"LI",{});var gb=r(qo);iu=o(gb,"LayoutLMv3"),gb.forEach(t),cu=p(h),Xo=n(h,"LI",{});var Tb=r(Xo);du=o(Tb,"LeViT"),Tb.forEach(t),pu=p(h),zo=n(h,"LI",{});var Ub=r(zo);uu=o(Ub,"LongT5"),Ub.forEach(t),mu=p(h),Go=n(h,"LI",{});var $b=r(Go);fu=o($b,"M2M100"),$b.forEach(t),hu=p(h),So=n(h,"LI",{});var Cb=r(So);Mu=o(Cb,"Marian"),Cb.forEach(t),yu=p(h),Vo=n(h,"LI",{});var Jb=r(Vo);vu=o(Jb,"mBART"),Jb.forEach(t),bu=p(h),Oo=n(h,"LI",{});var Nb=r(Oo);Eu=o(Nb,"MobileBERT"),Nb.forEach(t),ju=p(h),Po=n(h,"LI",{});var Ib=r(Po);wu=o(Ib,"MobileViT"),Ib.forEach(t),_u=p(h),Do=n(h,"LI",{});var kb=r(Do);gu=o(kb,"MT5"),kb.forEach(t),Tu=p(h),Lo=n(h,"LI",{});var Ab=r(Lo);Uu=o(Ab,"OpenAI GPT-2"),Ab.forEach(t),$u=p(h),Fo=n(h,"LI",{});var Zb=r(Fo);Cu=o(Zb,"Perceiver"),Zb.forEach(t),Ju=p(h),Qo=n(h,"LI",{});var Bb=r(Qo);Nu=o(Bb,"PLBart"),Bb.forEach(t),Iu=p(h),Ho=n(h,"LI",{});var xb=r(Ho);ku=o(xb,"ResNet"),xb.forEach(t),Au=p(h),Yo=n(h,"LI",{});var Wb=r(Yo);Zu=o(Wb,"RoBERTa"),Wb.forEach(t),Bu=p(h),Ko=n(h,"LI",{});var Rb=r(Ko);xu=o(Rb,"RoFormer"),Rb.forEach(t),Wu=p(h),es=n(h,"LI",{});var qb=r(es);Ru=o(qb,"SqueezeBERT"),qb.forEach(t),qu=p(h),as=n(h,"LI",{});var Xb=r(as);Xu=o(Xb,"T5"),Xb.forEach(t),zu=p(h),ts=n(h,"LI",{});var zb=r(ts);Gu=o(zb,"ViT"),zb.forEach(t),Su=p(h),ls=n(h,"LI",{});var Gb=r(ls);Vu=o(Gb,"XLM"),Gb.forEach(t),Ou=p(h),os=n(h,"LI",{});var Sb=r(os);Pu=o(Sb,"XLM-RoBERTa"),Sb.forEach(t),Du=p(h),ss=n(h,"LI",{});var Vb=r(ss);Lu=o(Vb,"XLM-RoBERTa-XL"),Vb.forEach(t),Fu=p(h),ns=n(h,"LI",{});var Ob=r(ns);Qu=o(Ob,"YOLOS"),Ob.forEach(t),h.forEach(t),Lr=p(e),vl=n(e,"P",{});var Pb=r(vl);Hu=o(Pb,"En las pr\xF3ximas dos secciones, te mostraremos c\xF3mo:"),Pb.forEach(t),Fr=p(e),Fe=n(e,"UL",{});var ed=r(Fe);Da=n(ed,"LI",{});var ad=r(Da);Yu=o(ad,"Exportar un modelo compatible utilizando el paquete "),rs=n(ad,"CODE",{});var Db=r(rs);Ku=o(Db,"transformers.onnx"),Db.forEach(t),em=o(ad,"."),ad.forEach(t),am=p(ed),is=n(ed,"LI",{});var Lb=r(is);tm=o(Lb,"Exportar un modelo personalizado para una arquitectura no compatible."),Lb.forEach(t),ed.forEach(t),Qr=p(e),we=n(e,"H3",{class:!0});var td=r(we);Qe=n(td,"A",{id:!0,class:!0,href:!0});var Fb=r(Qe);cs=n(Fb,"SPAN",{});var Qb=r(cs);b(La.$$.fragment,Qb),Qb.forEach(t),Fb.forEach(t),lm=p(td),ds=n(td,"SPAN",{});var Hb=r(ds);om=o(Hb,"Exportar un model a ONNX"),Hb.forEach(t),td.forEach(t),Hr=p(e),bl=n(e,"P",{});var Yb=r(bl);sm=o(Yb,`Para exportar un modelo \u{1F917} Transformers a ONNX, tienes que instalar primero algunas
dependencias extra:`),Yb.forEach(t),Yr=p(e),b(Fa.$$.fragment,e),Kr=p(e),He=n(e,"P",{});var ld=r(He);nm=o(ld,"El paquete "),ps=n(ld,"CODE",{});var Kb=r(ps);rm=o(Kb,"transformers.onnx"),Kb.forEach(t),im=o(ld," puede ser usado luego como un m\xF3dulo de Python:"),ld.forEach(t),ei=p(e),b(Qa.$$.fragment,e),ai=p(e),El=n(e,"P",{});var eE=r(El);cm=o(eE,"Exportar un checkpoint usando una configuraci\xF3n a la medida se puede hacer de la siguiente manera:"),eE.forEach(t),ti=p(e),b(Ha.$$.fragment,e),li=p(e),jl=n(e,"P",{});var aE=r(jl);dm=o(aE,"que deber\xEDa mostrar los siguientes registros:"),aE.forEach(t),oi=p(e),b(Ya.$$.fragment,e),si=p(e),re=n(e,"P",{});var Dl=r(re);pm=o(Dl,"Esto exporta un grafo ONNX del checkpoint definido por el argumento "),us=n(Dl,"CODE",{});var tE=r(us);um=o(tE,"--model"),tE.forEach(t),mm=o(Dl,`.
En este ejemplo, es un modelo `),ms=n(Dl,"CODE",{});var lE=r(ms);fm=o(lE,"distilbert-base-uncased"),lE.forEach(t),hm=o(Dl,`, pero puede ser cualquier
checkpoint en Hugging Face Hub o que est\xE9 almacenado localmente.`),Dl.forEach(t),ni=p(e),Y=n(e,"P",{});var qa=r(Y);Mm=o(qa,"El archivo "),fs=n(qa,"CODE",{});var oE=r(fs);ym=o(oE,"model.onnx"),oE.forEach(t),vm=o(qa,` resultante se puede ejecutar en uno de los
`),Ka=n(qa,"A",{href:!0,rel:!0});var sE=r(Ka);bm=o(sE,"muchos aceleradores"),sE.forEach(t),Em=o(qa,`
que admiten el est\xE1ndar ONNX. Por ejemplo, podemos cargar y ejecutar el
modelo con `),et=n(qa,"A",{href:!0,rel:!0});var nE=r(et);jm=o(nE,"ONNX Runtime"),nE.forEach(t),wm=o(qa," de la siguiente manera:"),qa.forEach(t),ri=p(e),b(at.$$.fragment,e),ii=p(e),Ye=n(e,"P",{});var od=r(Ye);_m=o(od,"Los nombres necesarios de salida (es decir, "),hs=n(od,"CODE",{});var rE=r(hs);gm=o(rE,'["last_hidden_state"]'),rE.forEach(t),Tm=o(od,`) se pueden obtener
echando un vistazo a la configuraci\xF3n ONNX de cada modelo. Por ejemplo, para DistilBERT tenemos:`),od.forEach(t),ci=p(e),b(tt.$$.fragment,e),di=p(e),Ke=n(e,"P",{});var sd=r(Ke);Um=o(sd,`El proceso es id\xE9ntico para los checkpoints de TensorFlow en Hub.
Por ejemplo, podemos exportar un checkpoint puro de TensorFlow desde
`),lt=n(sd,"A",{href:!0,rel:!0});var iE=r(lt);$m=o(iE,"Keras"),iE.forEach(t),Cm=o(sd," de la siguiente manera:"),sd.forEach(t),pi=p(e),b(ot.$$.fragment,e),ui=p(e),wl=n(e,"P",{});var cE=r(wl);Jm=o(cE,`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:`),cE.forEach(t),mi=p(e),b(ea.$$.fragment,e),fi=p(e),_e=n(e,"H3",{class:!0});var nd=r(_e);aa=n(nd,"A",{id:!0,class:!0,href:!0});var dE=r(aa);Ms=n(dE,"SPAN",{});var pE=r(Ms);b(st.$$.fragment,pE),pE.forEach(t),dE.forEach(t),Nm=p(nd),ys=n(nd,"SPAN",{});var uE=r(ys);Im=o(uE,"Seleccionar caracter\xEDsticas para diferentes topolog\xEDas de un modelo"),uE.forEach(t),nd.forEach(t),hi=p(e),ta=n(e,"P",{});var rd=r(ta);km=o(rd,"Cada configuraci\xF3n a la medida viene con un conjunto de "),vs=n(rd,"EM",{});var mE=r(vs);Am=o(mE,"caracter\xEDsticas"),mE.forEach(t),Zm=o(rd,` 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:`),rd.forEach(t),Mi=p(e),la=n(e,"TABLE",{});var id=r(la);bs=n(id,"THEAD",{});var fE=r(bs);nt=n(fE,"TR",{});var cd=r(nt);Es=n(cd,"TH",{});var hE=r(Es);Bm=o(hE,"Feature"),hE.forEach(t),xm=p(cd),js=n(cd,"TH",{});var ME=r(js);Wm=o(ME,"Auto Class"),ME.forEach(t),cd.forEach(t),fE.forEach(t),Rm=p(id),z=n(id,"TBODY",{});var L=r(z);rt=n(L,"TR",{});var dd=r(rt);it=n(dd,"TD",{});var pd=r(it);ws=n(pd,"CODE",{});var yE=r(ws);qm=o(yE,"causal-lm"),yE.forEach(t),Xm=o(pd,", "),_s=n(pd,"CODE",{});var vE=r(_s);zm=o(vE,"causal-lm-with-past"),vE.forEach(t),pd.forEach(t),Gm=p(dd),gs=n(dd,"TD",{});var bE=r(gs);Ts=n(bE,"CODE",{});var EE=r(Ts);Sm=o(EE,"AutoModelForCausalLM"),EE.forEach(t),bE.forEach(t),dd.forEach(t),Vm=p(L),ct=n(L,"TR",{});var ud=r(ct);dt=n(ud,"TD",{});var md=r(dt);Us=n(md,"CODE",{});var jE=r(Us);Om=o(jE,"default"),jE.forEach(t),Pm=o(md,", "),$s=n(md,"CODE",{});var wE=r($s);Dm=o(wE,"default-with-past"),wE.forEach(t),md.forEach(t),Lm=p(ud),Cs=n(ud,"TD",{});var _E=r(Cs);Js=n(_E,"CODE",{});var gE=r(Js);Fm=o(gE,"AutoModel"),gE.forEach(t),_E.forEach(t),ud.forEach(t),Qm=p(L),pt=n(L,"TR",{});var fd=r(pt);Ns=n(fd,"TD",{});var TE=r(Ns);Is=n(TE,"CODE",{});var UE=r(Is);Hm=o(UE,"masked-lm"),UE.forEach(t),TE.forEach(t),Ym=p(fd),ks=n(fd,"TD",{});var $E=r(ks);As=n($E,"CODE",{});var CE=r(As);Km=o(CE,"AutoModelForMaskedLM"),CE.forEach(t),$E.forEach(t),fd.forEach(t),ef=p(L),ut=n(L,"TR",{});var hd=r(ut);Zs=n(hd,"TD",{});var JE=r(Zs);Bs=n(JE,"CODE",{});var NE=r(Bs);af=o(NE,"question-answering"),NE.forEach(t),JE.forEach(t),tf=p(hd),xs=n(hd,"TD",{});var IE=r(xs);Ws=n(IE,"CODE",{});var kE=r(Ws);lf=o(kE,"AutoModelForQuestionAnswering"),kE.forEach(t),IE.forEach(t),hd.forEach(t),of=p(L),mt=n(L,"TR",{});var Md=r(mt);ft=n(Md,"TD",{});var yd=r(ft);Rs=n(yd,"CODE",{});var AE=r(Rs);sf=o(AE,"seq2seq-lm"),AE.forEach(t),nf=o(yd,", "),qs=n(yd,"CODE",{});var ZE=r(qs);rf=o(ZE,"seq2seq-lm-with-past"),ZE.forEach(t),yd.forEach(t),cf=p(Md),Xs=n(Md,"TD",{});var BE=r(Xs);zs=n(BE,"CODE",{});var xE=r(zs);df=o(xE,"AutoModelForSeq2SeqLM"),xE.forEach(t),BE.forEach(t),Md.forEach(t),pf=p(L),ht=n(L,"TR",{});var vd=r(ht);Gs=n(vd,"TD",{});var WE=r(Gs);Ss=n(WE,"CODE",{});var RE=r(Ss);uf=o(RE,"sequence-classification"),RE.forEach(t),WE.forEach(t),mf=p(vd),Vs=n(vd,"TD",{});var qE=r(Vs);Os=n(qE,"CODE",{});var XE=r(Os);ff=o(XE,"AutoModelForSequenceClassification"),XE.forEach(t),qE.forEach(t),vd.forEach(t),hf=p(L),Mt=n(L,"TR",{});var bd=r(Mt);Ps=n(bd,"TD",{});var zE=r(Ps);Ds=n(zE,"CODE",{});var GE=r(Ds);Mf=o(GE,"token-classification"),GE.forEach(t),zE.forEach(t),yf=p(bd),Ls=n(bd,"TD",{});var SE=r(Ls);Fs=n(SE,"CODE",{});var VE=r(Fs);vf=o(VE,"AutoModelForTokenClassification"),VE.forEach(t),SE.forEach(t),bd.forEach(t),L.forEach(t),id.forEach(t),yi=p(e),oa=n(e,"P",{});var Ed=r(oa);bf=o(Ed,"Para cada configuraci\xF3n, puedes encontrar la lista de funciones admitidas a trav\xE9s de "),Qs=n(Ed,"CODE",{});var OE=r(Qs);Ef=o(OE,"FeaturesManager"),OE.forEach(t),jf=o(Ed,`.
Por ejemplo, para DistilBERT tenemos:`),Ed.forEach(t),vi=p(e),b(yt.$$.fragment,e),bi=p(e),ie=n(e,"P",{});var Ll=r(ie);wf=o(Ll,"Le puedes pasar una de estas caracter\xEDsticas al argumento "),Hs=n(Ll,"CODE",{});var PE=r(Hs);_f=o(PE,"--feature"),PE.forEach(t),gf=o(Ll," en el paquete "),Ys=n(Ll,"CODE",{});var DE=r(Ys);Tf=o(DE,"transformers.onnx"),DE.forEach(t),Uf=o(Ll,`.
Por ejemplo, para exportar un modelo de clasificaci\xF3n de texto, podemos elegir un modelo ya ajustado del Hub y ejecutar:`),Ll.forEach(t),Ei=p(e),b(vt.$$.fragment,e),ji=p(e),_l=n(e,"P",{});var LE=r(_l);$f=o(LE,"que mostrar\xE1 los siguientes registros:"),LE.forEach(t),wi=p(e),b(bt.$$.fragment,e),_i=p(e),K=n(e,"P",{});var Xa=r(K);Cf=o(Xa,"Ten en cuenta que, en este caso, los nombres de salida del modelo ajustado son "),Ks=n(Xa,"CODE",{});var FE=r(Ks);Jf=o(FE,"logits"),FE.forEach(t),Nf=o(Xa," en lugar de "),en=n(Xa,"CODE",{});var QE=r(en);If=o(QE,"last_hidden_state"),QE.forEach(t),kf=o(Xa,`
que vimos anteriormente con el checkpoint `),an=n(Xa,"CODE",{});var HE=r(an);Af=o(HE,"distilbert-base-uncased"),HE.forEach(t),Zf=o(Xa,`. Esto es de esperarse ya que el modelo ajustado
tiene un cabezal de clasificaci\xF3n secuencial.`),Xa.forEach(t),gi=p(e),b(sa.$$.fragment,e),Ti=p(e),ge=n(e,"H3",{class:!0});var jd=r(ge);na=n(jd,"A",{id:!0,class:!0,href:!0});var YE=r(na);tn=n(YE,"SPAN",{});var KE=r(tn);b(Et.$$.fragment,KE),KE.forEach(t),YE.forEach(t),Bf=p(jd),ln=n(jd,"SPAN",{});var e2=r(ln);xf=o(e2,"Exportar un modelo para una arquitectura no compatible"),e2.forEach(t),jd.forEach(t),Ui=p(e),gl=n(e,"P",{});var a2=r(gl);Wf=o(a2,`Si deseas exportar un modelo cuya arquitectura no es compatible de forma nativa
con la biblioteca, debes seguir tres pasos principales:`),a2.forEach(t),$i=p(e),ce=n(e,"OL",{});var Fl=r(ce);on=n(Fl,"LI",{});var t2=r(on);Rf=o(t2,"Implementa una configuraci\xF3n personalizada en ONNX."),t2.forEach(t),qf=p(Fl),sn=n(Fl,"LI",{});var l2=r(sn);Xf=o(l2,"Exporta el modelo a ONNX."),l2.forEach(t),zf=p(Fl),nn=n(Fl,"LI",{});var o2=r(nn);Gf=o(o2,"Valide los resultados de PyTorch y los modelos exportados."),o2.forEach(t),Fl.forEach(t),Ci=p(e),Tl=n(e,"P",{});var s2=r(Tl);Sf=o(s2,`En esta secci\xF3n, veremos c\xF3mo se implement\xF3 la serializaci\xF3n de DistilBERT
para mostrar lo que implica cada paso.`),s2.forEach(t),Ji=p(e),Te=n(e,"H4",{class:!0});var wd=r(Te);ra=n(wd,"A",{id:!0,class:!0,href:!0});var n2=r(ra);rn=n(n2,"SPAN",{});var r2=r(rn);b(jt.$$.fragment,r2),r2.forEach(t),n2.forEach(t),Vf=p(wd),cn=n(wd,"SPAN",{});var i2=r(cn);Of=o(i2,"Implementar una configuraci\xF3n personalizada en ONNX"),i2.forEach(t),wd.forEach(t),Ni=p(e),Ul=n(e,"P",{});var c2=r(Ul);Pf=o(c2,`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:`),c2.forEach(t),Ii=p(e),de=n(e,"UL",{});var Ql=r(de);ia=n(Ql,"LI",{});var zr=r(ia);Df=o(zr,"Modelos basados en el "),dn=n(zr,"EM",{});var d2=r(dn);Lf=o(d2,"Encoder"),d2.forEach(t),Ff=o(zr," inherente de "),pn=n(zr,"CODE",{});var p2=r(pn);Qf=o(p2,"OnnxConfig"),p2.forEach(t),zr.forEach(t),Hf=p(Ql),ca=n(Ql,"LI",{});var Gr=r(ca);Yf=o(Gr,"Modelos basados en el "),un=n(Gr,"EM",{});var u2=r(un);Kf=o(u2,"Decoder"),u2.forEach(t),eh=o(Gr," inherente de "),mn=n(Gr,"CODE",{});var m2=r(mn);ah=o(m2,"OnnxConfigWithPast"),m2.forEach(t),Gr.forEach(t),th=p(Ql),da=n(Ql,"LI",{});var Sr=r(da);lh=o(Sr,"Modelos "),fn=n(Sr,"EM",{});var f2=r(fn);oh=o(f2,"Encoder-decoder"),f2.forEach(t),sh=o(Sr," inherente de "),hn=n(Sr,"CODE",{});var h2=r(hn);nh=o(h2,"OnnxSeq2SeqConfigWithPast"),h2.forEach(t),Sr.forEach(t),Ql.forEach(t),ki=p(e),b(pa.$$.fragment,e),Ai=p(e),pe=n(e,"P",{});var Hl=r(pe);rh=o(Hl,"Dado que DistilBERT es un modelo de tipo "),Mn=n(Hl,"EM",{});var M2=r(Mn);ih=o(M2,"encoder"),M2.forEach(t),ch=o(Hl,", su configuraci\xF3n se hereda de "),yn=n(Hl,"CODE",{});var y2=r(yn);dh=o(y2,"OnnxConfig"),y2.forEach(t),ph=o(Hl,":"),Hl.forEach(t),Zi=p(e),b(wt.$$.fragment,e),Bi=p(e),P=n(e,"P",{});var ve=r(P);uh=o(ve,"Cada objeto de configuraci\xF3n debe implementar la propiedad "),vn=n(ve,"CODE",{});var v2=r(vn);mh=o(v2,"inputs"),v2.forEach(t),fh=o(ve,` 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: `),bn=n(ve,"CODE",{});var b2=r(bn);hh=o(b2,"input_ids"),b2.forEach(t),Mh=o(ve," y "),En=n(ve,"CODE",{});var E2=r(En);yh=o(E2,"attention_mask"),E2.forEach(t),vh=o(ve,`.
Estas entradas tienen la misma forma de `),jn=n(ve,"CODE",{});var j2=r(jn);bh=o(j2,"(batch_size, sequence_length)"),j2.forEach(t),Eh=o(ve,`, es por lo que vemos
los mismos ejes utilizados en la configuraci\xF3n.`),ve.forEach(t),xi=p(e),b(ua.$$.fragment,e),Wi=p(e),$l=n(e,"P",{});var w2=r($l);jh=o(w2,`Una vez que hayas implementado una configuraci\xF3n ONNX, puedes crear una
instancia proporcionando la configuraci\xF3n del modelo base de la siguiente manera:`),w2.forEach(t),Ri=p(e),b(_t.$$.fragment,e),qi=p(e),Cl=n(e,"P",{});var _2=r(Cl);wh=o(_2,`El objeto resultante tiene varias propiedades \xFAtiles. Por ejemplo, puedes ver el conjunto de operadores ONNX que se
utilizar\xE1 durante la exportaci\xF3n:`),_2.forEach(t),Xi=p(e),b(gt.$$.fragment,e),zi=p(e),Jl=n(e,"P",{});var g2=r(Jl);_h=o(g2,"Tambi\xE9n puedes ver los resultados asociados con el modelo de la siguiente manera:"),g2.forEach(t),Gi=p(e),b(Tt.$$.fragment,e),Si=p(e),D=n(e,"P",{});var be=r(D);gh=o(be,`Observa que la propiedad de salidas sigue la misma estructura que las entradas;
devuelve un objecto `),wn=n(be,"CODE",{});var T2=r(wn);Th=o(T2,"OrderedDict"),T2.forEach(t),Uh=o(be,` 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 `),_n=n(be,"CODE",{});var U2=r(_n);$h=o(U2,"default"),U2.forEach(t),Ch=o(be,` que
corresponde a exportar un modelo cargado con la clase `),gn=n(be,"CODE",{});var $2=r(gn);Jh=o($2,"AutoModel"),$2.forEach(t),Nh=o(be,`. Si quieres exportar
una topolog\xEDa de modelo diferente, simplemente proporciona una caracter\xEDstica diferente
al argumento `),Tn=n(be,"CODE",{});var C2=r(Tn);Ih=o(C2,"task"),C2.forEach(t),kh=o(be,` 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:`),be.forEach(t),Vi=p(e),b(Ut.$$.fragment,e),Oi=p(e),b(ma.$$.fragment,e),Pi=p(e),Ue=n(e,"H4",{class:!0});var _d=r(Ue);fa=n(_d,"A",{id:!0,class:!0,href:!0});var J2=r(fa);Un=n(J2,"SPAN",{});var N2=r(Un);b($t.$$.fragment,N2),N2.forEach(t),J2.forEach(t),Ah=p(_d),$n=n(_d,"SPAN",{});var I2=r($n);Zh=o(I2,"Exportar el modelo"),I2.forEach(t),_d.forEach(t),Di=p(e),ue=n(e,"P",{});var Yl=r(ue);Bh=o(Yl,`Una vez que hayas implementado la configuraci\xF3n de ONNX, el siguiente paso es exportar el modelo.
Aqu\xED podemos usar la funci\xF3n `),Cn=n(Yl,"CODE",{});var k2=r(Cn);xh=o(k2,"export()"),k2.forEach(t),Wh=o(Yl," proporcionada por el paquete "),Jn=n(Yl,"CODE",{});var A2=r(Jn);Rh=o(A2,"transformers.onnx"),A2.forEach(t),qh=o(Yl,`.
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:`),Yl.forEach(t),Li=p(e),b(Ct.$$.fragment,e),Fi=p(e),G=n(e,"P",{});var le=r(G);Xh=o(le,"Los objetos "),Nn=n(le,"CODE",{});var Z2=r(Nn);zh=o(Z2,"onnx_inputs"),Z2.forEach(t),Gh=o(le," y "),In=n(le,"CODE",{});var B2=r(In);Sh=o(B2,"onnx_outputs"),B2.forEach(t),Vh=o(le," devueltos por la funci\xF3n "),kn=n(le,"CODE",{});var x2=r(kn);Oh=o(x2,"export()"),x2.forEach(t),Ph=o(le,`
son listas de llaves definidas en las propiedades `),An=n(le,"CODE",{});var W2=r(An);Dh=o(W2,"inputs"),W2.forEach(t),Lh=o(le," y "),Zn=n(le,"CODE",{});var R2=r(Zn);Fh=o(R2,"outputs"),R2.forEach(t),Qh=o(le,` de la configuraci\xF3n.
Una vez exportado el modelo, puedes probar que el modelo est\xE1 bien formado de la siguiente manera:`),le.forEach(t),Qi=p(e),b(Jt.$$.fragment,e),Hi=p(e),b(ha.$$.fragment,e),Yi=p(e),$e=n(e,"H4",{class:!0});var gd=r($e);Ma=n(gd,"A",{id:!0,class:!0,href:!0});var q2=r(Ma);Bn=n(q2,"SPAN",{});var X2=r(Bn);b(Nt.$$.fragment,X2),X2.forEach(t),q2.forEach(t),Hh=p(gd),xn=n(gd,"SPAN",{});var z2=r(xn);Yh=o(z2,"Validar los resultados del modelo"),z2.forEach(t),gd.forEach(t),Ki=p(e),me=n(e,"P",{});var Kl=r(me);Kh=o(Kl,`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 `),Wn=n(Kl,"CODE",{});var G2=r(Wn);eM=o(G2,"validate_model_outputs()"),G2.forEach(t),aM=o(Kl,`
proporcionada por el paquete `),Rn=n(Kl,"CODE",{});var S2=r(Rn);tM=o(S2,"transformers.onnx"),S2.forEach(t),lM=o(Kl," de la siguiente manera:"),Kl.forEach(t),ec=p(e),b(It.$$.fragment,e),ac=p(e),ya=n(e,"P",{});var Td=r(ya);oM=o(Td,"Esta funci\xF3n usa el m\xE9todo "),qn=n(Td,"CODE",{});var V2=r(qn);sM=o(V2,"OnnxConfig.generate_dummy_inputs()"),V2.forEach(t),nM=o(Td,` 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.`),Td.forEach(t),tc=p(e),Ce=n(e,"H3",{class:!0});var Ud=r(Ce);va=n(Ud,"A",{id:!0,class:!0,href:!0});var O2=r(va);Xn=n(O2,"SPAN",{});var P2=r(Xn);b(kt.$$.fragment,P2),P2.forEach(t),O2.forEach(t),rM=p(Ud),zn=n(Ud,"SPAN",{});var D2=r(zn);iM=o(D2,"Contribuir con una nueva configuraci\xF3n a \u{1F917} Transformers"),D2.forEach(t),Ud.forEach(t),lc=p(e),Nl=n(e,"P",{});var L2=r(Nl);cM=o(L2,`\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:`),L2.forEach(t),oc=p(e),fe=n(e,"UL",{});var eo=r(fe);At=n(eo,"LI",{});var $d=r(At);dM=o($d,"Implementa la configuraci\xF3n de ONNX en el archivo "),Gn=n($d,"CODE",{});var F2=r(Gn);pM=o(F2,"configuration_<model_name>.py"),F2.forEach(t),uM=o($d," correspondiente"),$d.forEach(t),mM=p(eo),Il=n(eo,"LI",{});var Wv=r(Il);fM=o(Wv,"Incluye la arquitectura del modelo y las caracter\xEDsticas correspondientes en "),Sn=n(Wv,"CODE",{});var Q2=r(Sn);hM=o(Q2,"~onnx.features.FeatureManager"),Q2.forEach(t),Wv.forEach(t),MM=p(eo),kl=n(eo,"LI",{});var Rv=r(kl);yM=o(Rv,"Agrega tu arquitectura de modelo a las pruebas en "),Vn=n(Rv,"CODE",{});var H2=r(Vn);vM=o(H2,"test_onnx_v2.py"),H2.forEach(t),Rv.forEach(t),eo.forEach(t),sc=p(e),ba=n(e,"P",{});var Cd=r(ba);bM=o(Cd,"Revisa c\xF3mo fue la contribuci\xF3n para la "),Zt=n(Cd,"A",{href:!0,rel:!0});var Y2=r(Zt);EM=o(Y2,"configuraci\xF3n de IBERT"),Y2.forEach(t),jM=o(Cd,`
y as\xED tener una idea de lo que necesito.`),Cd.forEach(t),nc=p(e),Je=n(e,"H2",{class:!0});var Jd=r(Je);Ea=n(Jd,"A",{id:!0,class:!0,href:!0});var K2=r(Ea);On=n(K2,"SPAN",{});var ej=r(On);b(Bt.$$.fragment,ej),ej.forEach(t),K2.forEach(t),wM=p(Jd),Pn=n(Jd,"SPAN",{});var aj=r(Pn);_M=o(aj,"TorchScript"),aj.forEach(t),Jd.forEach(t),rc=p(e),b(ja.$$.fragment,e),ic=p(e),wa=n(e,"P",{});var Nd=r(wa);gM=o(Nd,`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 `),xt=n(Nd,"A",{href:!0,rel:!0});var tj=r(xt);TM=o(tj,"JIT y TRACE"),tj.forEach(t),UM=o(Nd,` permiten al
desarrollador exportar su modelo para reutilizarlo  en otros programas, como los programas C++ orientados a la eficiencia.`),Nd.forEach(t),cc=p(e),Al=n(e,"P",{});var lj=r(Al);$M=o(lj,`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.`),lj.forEach(t),dc=p(e),Zl=n(e,"P",{});var oj=r(Zl);CM=o(oj,"Exportar un modelo requiere de dos cosas:"),oj.forEach(t),pc=p(e),_a=n(e,"UL",{});var Id=r(_a);Dn=n(Id,"LI",{});var sj=r(Dn);JM=o(sj,"un pase hacia adelante con entradas ficticias."),sj.forEach(t),NM=p(Id),Wt=n(Id,"LI",{});var kd=r(Wt);IM=o(kd,"instanciaci\xF3n del modelo con la indicador "),Ln=n(kd,"CODE",{});var nj=r(Ln);kM=o(nj,"torchscript"),nj.forEach(t),AM=o(kd,"."),kd.forEach(t),Id.forEach(t),uc=p(e),Bl=n(e,"P",{});var rj=r(Bl);ZM=o(rj,"Estas necesidades implican varias cosas con las que los desarrolladores deben tener cuidado. \xC9stas se detallan a continuaci\xF3n."),rj.forEach(t),mc=p(e),Ne=n(e,"H3",{class:!0});var Ad=r(Ne);ga=n(Ad,"A",{id:!0,class:!0,href:!0});var ij=r(ga);Fn=n(ij,"SPAN",{});var cj=r(Fn);b(Rt.$$.fragment,cj),cj.forEach(t),ij.forEach(t),BM=p(Ad),Qn=n(Ad,"SPAN",{});var dj=r(Qn);xM=o(dj,"Indicador de TorchScript y pesos atados"),dj.forEach(t),Ad.forEach(t),fc=p(e),he=n(e,"P",{});var ao=r(he);WM=o(ao,`Este indicador es necesario porque la mayor\xEDa de los modelos de lenguaje en este repositorio tienen pesos vinculados entre su capa
de `),Hn=n(ao,"CODE",{});var pj=r(Hn);RM=o(pj,"Embedding"),pj.forEach(t),qM=o(ao," y su capa de "),Yn=n(ao,"CODE",{});var uj=r(Yn);XM=o(uj,"Decoding"),uj.forEach(t),zM=o(ao,`. TorchScript no permite la exportaci\xF3n de modelos que tengan pesos atados, por lo que es
necesario desvincular y clonar los pesos previamente.`),ao.forEach(t),hc=p(e),ee=n(e,"P",{});var za=r(ee);GM=o(za,"Esto implica que los modelos instanciados con el indicador "),Kn=n(za,"CODE",{});var mj=r(Kn);SM=o(mj,"torchscript"),mj.forEach(t),VM=o(za," tienen su capa "),er=n(za,"CODE",{});var fj=r(er);OM=o(fj,"Embedding"),fj.forEach(t),PM=o(za," y "),ar=n(za,"CODE",{});var hj=r(ar);DM=o(hj,"Decoding"),hj.forEach(t),LM=o(za,` separadas,
lo que significa que no deben entrenarse m\xE1s adelante. El entrenamiento desincronizar\xEDa las dos capas, lo que generar\xEDa
resultados inesperados.`),za.forEach(t),Mc=p(e),Ta=n(e,"P",{});var Zd=r(Ta);FM=o(Zd,`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 `),tr=n(Zd,"CODE",{});var Mj=r(tr);QM=o(Mj,"torchscript"),Mj.forEach(t),HM=o(Zd,"."),Zd.forEach(t),yc=p(e),Ie=n(e,"H3",{class:!0});var Bd=r(Ie);Ua=n(Bd,"A",{id:!0,class:!0,href:!0});var yj=r(Ua);lr=n(yj,"SPAN",{});var vj=r(lr);b(qt.$$.fragment,vj),vj.forEach(t),yj.forEach(t),YM=p(Bd),or=n(Bd,"SPAN",{});var bj=r(or);KM=o(bj,"Entradas ficticias y longitudes est\xE1ndar"),bj.forEach(t),Bd.forEach(t),vc=p(e),xl=n(e,"P",{});var Ej=r(xl);ey=o(Ej,`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.`),Ej.forEach(t),bc=p(e),Wl=n(e,"P",{});var jj=r(Wl);ay=o(jj,`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:`),jj.forEach(t),Ec=p(e),Rl=n(e,"P",{});var wj=r(Rl);sr=n(wj,"CODE",{});var _j=r(sr);ty=o(_j,"The expanded size of the tensor (3) must match the existing size (7) at non-singleton dimension 2"),_j.forEach(t),wj.forEach(t),jc=p(e),$a=n(e,"P",{});var xd=r($a);ly=o(xd,`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 `),nr=n(xd,"EM",{});var gj=r(nr);oy=o(gj,"padding"),gj.forEach(t),sy=o(xd,` 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.forEach(t),wc=p(e),ql=n(e,"P",{});var Tj=r(ql);ny=o(Tj,`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.`),Tj.forEach(t),_c=p(e),ke=n(e,"H3",{class:!0});var Wd=r(ke);Ca=n(Wd,"A",{id:!0,class:!0,href:!0});var Uj=r(Ca);rr=n(Uj,"SPAN",{});var $j=r(rr);b(Xt.$$.fragment,$j),$j.forEach(t),Uj.forEach(t),ry=p(Wd),ir=n(Wd,"SPAN",{});var Cj=r(ir);iy=o(Cj,"Usar TorchScript en Python"),Cj.forEach(t),Wd.forEach(t),gc=p(e),Xl=n(e,"P",{});var Jj=r(Xl);cy=o(Jj,"A continuaci\xF3n se muestra un ejemplo que muestra c\xF3mo guardar, cargar modelos y c\xF3mo usar el rastreo para la inferencia."),Jj.forEach(t),Tc=p(e),Ae=n(e,"H4",{class:!0});var Rd=r(Ae);Ja=n(Rd,"A",{id:!0,class:!0,href:!0});var Nj=r(Ja);cr=n(Nj,"SPAN",{});var Ij=r(cr);b(zt.$$.fragment,Ij),Ij.forEach(t),Nj.forEach(t),dy=p(Rd),dr=n(Rd,"SPAN",{});var kj=r(dr);py=o(kj,"Guardando un modelo"),kj.forEach(t),Rd.forEach(t),Uc=p(e),H=n(e,"P",{});var Oe=r(H);uy=o(Oe,"Este fragmento muestra c\xF3mo usar TorchScript para exportar un "),pr=n(Oe,"CODE",{});var Aj=r(pr);my=o(Aj,"BertModel"),Aj.forEach(t),fy=o(Oe,". Aqu\xED, el "),ur=n(Oe,"CODE",{});var Zj=r(ur);hy=o(Zj,"BertModel"),Zj.forEach(t),My=o(Oe,` se instancia de acuerdo
con la clase `),mr=n(Oe,"CODE",{});var Bj=r(mr);yy=o(Bj,"BertConfig"),Bj.forEach(t),vy=o(Oe," y luego se guarda en el disco con el nombre de archivo "),fr=n(Oe,"CODE",{});var xj=r(fr);by=o(xj,"traced_bert.pt"),xj.forEach(t),Oe.forEach(t),$c=p(e),b(Gt.$$.fragment,e),Cc=p(e),Ze=n(e,"H4",{class:!0});var qd=r(Ze);Na=n(qd,"A",{id:!0,class:!0,href:!0});var Wj=r(Na);hr=n(Wj,"SPAN",{});var Rj=r(hr);b(St.$$.fragment,Rj),Rj.forEach(t),Wj.forEach(t),Ey=p(qd),Mr=n(qd,"SPAN",{});var qj=r(Mr);jy=o(qj,"Cargar un modelo"),qj.forEach(t),qd.forEach(t),Jc=p(e),ae=n(e,"P",{});var Ga=r(ae);wy=o(Ga,"Este fragmento muestra c\xF3mo cargar el "),yr=n(Ga,"CODE",{});var Xj=r(yr);_y=o(Xj,"BertModel"),Xj.forEach(t),gy=o(Ga," que se guard\xF3 previamente en el disco con el nombre "),vr=n(Ga,"CODE",{});var zj=r(vr);Ty=o(zj,"traced_bert.pt"),zj.forEach(t),Uy=o(Ga,`.
Estamos reutilizando el `),br=n(Ga,"CODE",{});var Gj=r(br);$y=o(Gj,"dummy_input"),Gj.forEach(t),Cy=o(Ga," previamente inicializado."),Ga.forEach(t),Nc=p(e),b(Vt.$$.fragment,e),Ic=p(e),Be=n(e,"H4",{class:!0});var Xd=r(Be);Ia=n(Xd,"A",{id:!0,class:!0,href:!0});var Sj=r(Ia);Er=n(Sj,"SPAN",{});var Vj=r(Er);b(Ot.$$.fragment,Vj),Vj.forEach(t),Sj.forEach(t),Jy=p(Xd),jr=n(Xd,"SPAN",{});var Oj=r(jr);Ny=o(Oj,"Usar un modelo rastreado para la inferencia"),Oj.forEach(t),Xd.forEach(t),kc=p(e),ka=n(e,"P",{});var zd=r(ka);Iy=o(zd,"Usar el modelo rastreado para la inferencia es tan simple como usar su m\xE9todo "),wr=n(zd,"CODE",{});var Pj=r(wr);ky=o(Pj,"__call__"),Pj.forEach(t),Ay=o(zd,":"),zd.forEach(t),Ac=p(e),b(Pt.$$.fragment,e),Zc=p(e),xe=n(e,"H3",{class:!0});var Gd=r(xe);Aa=n(Gd,"A",{id:!0,class:!0,href:!0});var Dj=r(Aa);_r=n(Dj,"SPAN",{});var Lj=r(_r);b(Dt.$$.fragment,Lj),Lj.forEach(t),Dj.forEach(t),Zy=p(Gd),gr=n(Gd,"SPAN",{});var Fj=r(gr);By=o(Fj,"Implementar los modelos HuggingFace TorchScript en AWS mediante Neuron SDK"),Fj.forEach(t),Gd.forEach(t),Bc=p(e),Me=n(e,"P",{});var to=r(Me);xy=o(to,"AWS present\xF3 la familia de instancias "),Lt=n(to,"A",{href:!0,rel:!0});var Qj=r(Lt);Wy=o(Qj,"Amazon EC2 Inf1"),Qj.forEach(t),Ry=o(to,` 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. `),Ft=n(to,"A",{href:!0,rel:!0});var Hj=r(Ft);qy=o(Hj,"AWS Neuron"),Hj.forEach(t),Xy=o(to,` 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:`),to.forEach(t),xc=p(e),ye=n(e,"OL",{});var lo=r(ye);Tr=n(lo,"LI",{});var Yj=r(Tr);zy=o(Yj,"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."),Yj.forEach(t),Gy=p(lo),zl=n(lo,"LI",{});var qv=r(zl);Sy=o(qv,"Optimizaciones de rendimiento listas para usar con un "),Qt=n(qv,"A",{href:!0,rel:!0});var Kj=r(Qt);Vy=o(Kj,"costo-rendimiento mejorado"),Kj.forEach(t),qv.forEach(t),Oy=p(lo),We=n(lo,"LI",{});var oo=r(We);Py=o(oo,"Soporte para modelos HuggingFace Transformers construidos con "),Ht=n(oo,"A",{href:!0,rel:!0});var e1=r(Ht);Dy=o(e1,"PyTorch"),e1.forEach(t),Ly=o(oo,`
o `),Yt=n(oo,"A",{href:!0,rel:!0});var a1=r(Yt);Fy=o(a1,"TensorFlow"),a1.forEach(t),Qy=o(oo,"."),oo.forEach(t),lo.forEach(t),Wc=p(e),Re=n(e,"H4",{class:!0});var Sd=r(Re);Za=n(Sd,"A",{id:!0,class:!0,href:!0});var t1=r(Za);Ur=n(t1,"SPAN",{});var l1=r(Ur);b(Kt.$$.fragment,l1),l1.forEach(t),t1.forEach(t),Hy=p(Sd),$r=n(Sd,"SPAN",{});var o1=r($r);Yy=o(o1,"Implicaciones"),o1.forEach(t),Sd.forEach(t),Rc=p(e),S=n(e,"P",{});var oe=r(S);Ky=o(oe,`Los modelos Transformers basados en la arquitectura
`),qe=n(oe,"A",{href:!0,rel:!0});var Vd=r(qe);ev=o(Vd,"BERT (Representaciones de "),Cr=n(Vd,"EM",{});var s1=r(Cr);av=o(s1,"Enconder"),s1.forEach(t),tv=o(Vd," bidireccional de Transformers)"),Vd.forEach(t),lv=o(oe,`,
o sus variantes, como `),el=n(oe,"A",{href:!0,rel:!0});var n1=r(el);ov=o(n1,"distilBERT"),n1.forEach(t),sv=o(oe,` y
`),al=n(oe,"A",{href:!0,rel:!0});var r1=r(al);nv=o(r1,"roBERTa"),r1.forEach(t),rv=o(oe,`, 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
`),tl=n(oe,"A",{href:!0,rel:!0});var i1=r(tl);iv=o(i1,"tutorial de AWS Neuron MarianMT"),i1.forEach(t),cv=o(oe,`.
Puedes encontrar m\xE1s informaci\xF3n sobre los modelos que est\xE1n listos para usarse en Inferentia en la
`),Xe=n(oe,"A",{href:!0,rel:!0});var Od=r(Xe);dv=o(Od,"secci\xF3n "),Jr=n(Od,"EM",{});var c1=r(Jr);pv=o(c1,"Model Architecture Fit"),c1.forEach(t),uv=o(Od," de la documentaci\xF3n de Neuron"),Od.forEach(t),mv=o(oe,"."),oe.forEach(t),qc=p(e),ze=n(e,"H4",{class:!0});var Pd=r(ze);Ba=n(Pd,"A",{id:!0,class:!0,href:!0});var d1=r(Ba);Nr=n(d1,"SPAN",{});var p1=r(Nr);b(ll.$$.fragment,p1),p1.forEach(t),d1.forEach(t),fv=p(Pd),Ir=n(Pd,"SPAN",{});var u1=r(Ir);hv=o(u1,"Dependencias"),u1.forEach(t),Pd.forEach(t),Xc=p(e),Gl=n(e,"P",{});var m1=r(Gl);Mv=o(m1,"Usar AWS Neuron para convertir modelos requiere las siguientes dependencias y entornos:"),m1.forEach(t),zc=p(e),Sl=n(e,"UL",{});var f1=r(Sl);Ge=n(f1,"LI",{});var so=r(Ge);yv=o(so,"Un "),ol=n(so,"A",{href:!0,rel:!0});var h1=r(ol);vv=o(h1,"entorno Neuron SDK"),h1.forEach(t),bv=o(so,`,
que viene preconfigurado en `),sl=n(so,"A",{href:!0,rel:!0});var M1=r(sl);Ev=o(M1,"AWS Deep Learning AMI"),M1.forEach(t),jv=o(so,"."),so.forEach(t),f1.forEach(t),Gc=p(e),Se=n(e,"H4",{class:!0});var Dd=r(Se);xa=n(Dd,"A",{id:!0,class:!0,href:!0});var y1=r(xa);kr=n(y1,"SPAN",{});var v1=r(kr);b(nl.$$.fragment,v1),v1.forEach(t),y1.forEach(t),wv=p(Dd),Ar=n(Dd,"SPAN",{});var b1=r(Ar);_v=o(b1,"Convertir un modelo a AWS Neuron"),b1.forEach(t),Dd.forEach(t),Sc=p(e),te=n(e,"P",{});var Sa=r(te);gv=o(Sa,"Con el mismo script usado en "),rl=n(Sa,"A",{href:!0,rel:!0});var E1=r(rl);Tv=o(E1,"Uso de TorchScript en Python"),E1.forEach(t),Uv=o(Sa,`
para rastrear un \u201CBertModel\u201D, puedes importar la extensi\xF3n del `),Zr=n(Sa,"EM",{});var j1=r(Zr);$v=o(j1,"framework"),j1.forEach(t),Cv=p(Sa),Br=n(Sa,"CODE",{});var w1=r(Br);Jv=o(w1,"torch.neuron"),w1.forEach(t),Nv=o(Sa,` para acceder a los componentes
del SDK de Neuron a trav\xE9s de una API de Python.`),Sa.forEach(t),Vc=p(e),b(il.$$.fragment,e),Oc=p(e),Vl=n(e,"P",{});var _1=r(Vl);Iv=o(_1,"Y modificando la l\xEDnea de c\xF3digo de rastreo de:"),_1.forEach(t),Pc=p(e),b(cl.$$.fragment,e),Dc=p(e),Ol=n(e,"P",{});var g1=r(Ol);kv=o(g1,"con lo siguiente:"),g1.forEach(t),Lc=p(e),b(dl.$$.fragment,e),Fc=p(e),Pl=n(e,"P",{});var T1=r(Pl);Av=o(T1,"Este cambio permite a Neuron SDK rastrear el modelo y optimizarlo para ejecutarse en instancias Inf1."),T1.forEach(t),Qc=p(e),Wa=n(e,"P",{});var Ld=r(Wa);Zv=o(Ld,`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 `),pl=n(Ld,"A",{href:!0,rel:!0});var U1=r(pl);Bv=o(U1,"documentaci\xF3n de AWS NeuronSDK"),U1.forEach(t),xv=o(Ld,"."),Ld.forEach(t),this.h()},h(){u(m,"name","hf:doc:metadata"),u(m,"content",JSON.stringify(P1)),u(g,"id","exportar-modelos-transformers"),u(g,"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(g,"href","#exportar-modelos-transformers"),u(M,"class","relative group"),u(se,"href","https://github.com/huggingface/optimum"),u(se,"rel","nofollow"),u(O,"id","onnx"),u(O,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(O,"href","#onnx"),u(Q,"class","relative group"),u(Pa,"href","http://onnx.ai"),u(Pa,"rel","nofollow"),u(Qe,"id","exportar-un-model-a-onnx"),u(Qe,"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(Qe,"href","#exportar-un-model-a-onnx"),u(we,"class","relative group"),u(Ka,"href","https://onnx.ai/supported-tools.html#deployModel"),u(Ka,"rel","nofollow"),u(et,"href","https://onnxruntime.ai/"),u(et,"rel","nofollow"),u(lt,"href","https://huggingface.co/keras-io"),u(lt,"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(_e,"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(ge,"class","relative group"),u(ra,"id","implementar-una-configuracin-personalizada-en-onnx"),u(ra,"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(ra,"href","#implementar-una-configuracin-personalizada-en-onnx"),u(Te,"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(Ue,"class","relative group"),u(Ma,"id","validar-los-resultados-del-modelo"),u(Ma,"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(Ma,"href","#validar-los-resultados-del-modelo"),u($e,"class","relative group"),u(va,"id","contribuir-con-una-nueva-configuracin-a-transformers"),u(va,"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(va,"href","#contribuir-con-una-nueva-configuracin-a-transformers"),u(Ce,"class","relative group"),u(Zt,"href","https://github.com/huggingface/transformers/pull/14868/files"),u(Zt,"rel","nofollow"),u(Ea,"id","torchscript"),u(Ea,"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(Ea,"href","#torchscript"),u(Je,"class","relative group"),u(xt,"href","https://pytorch.org/docs/stable/jit.html"),u(xt,"rel","nofollow"),u(ga,"id","indicador-de-torchscript-y-pesos-atados"),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","#indicador-de-torchscript-y-pesos-atados"),u(Ne,"class","relative group"),u(Ua,"id","entradas-ficticias-y-longitudes-estndar"),u(Ua,"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(Ua,"href","#entradas-ficticias-y-longitudes-estndar"),u(Ie,"class","relative group"),u(Ca,"id","usar-torchscript-en-python"),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","#usar-torchscript-en-python"),u(ke,"class","relative group"),u(Ja,"id","guardando-un-modelo"),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","#guardando-un-modelo"),u(Ae,"class","relative group"),u(Na,"id","cargar-un-modelo"),u(Na,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),u(Na,"href","#cargar-un-modelo"),u(Ze,"class","relative group"),u(Ia,"id","usar-un-modelo-rastreado-para-la-inferencia"),u(Ia,"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(Ia,"href","#usar-un-modelo-rastreado-para-la-inferencia"),u(Be,"class","relative group"),u(Aa,"id","implementar-los-modelos-huggingface-torchscript-en-aws-mediante-neuron-sdk"),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","#implementar-los-modelos-huggingface-torchscript-en-aws-mediante-neuron-sdk"),u(xe,"class","relative group"),u(Lt,"href","https://aws.amazon.com/ec2/instance-types/inf1/"),u(Lt,"rel","nofollow"),u(Ft,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/#"),u(Ft,"rel","nofollow"),u(Qt,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/benchmark/%3E"),u(Qt,"rel","nofollow"),u(Ht,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/pytorch/bert_tutorial/tutorial_pretrained_bert.html"),u(Ht,"rel","nofollow"),u(Yt,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/tensorflow/huggingface_bert/huggingface_bert.html"),u(Yt,"rel","nofollow"),u(Za,"id","implicaciones"),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","#implicaciones"),u(Re,"class","relative group"),u(qe,"href","https://huggingface.co/docs/transformers/main/model_doc/bert"),u(qe,"rel","nofollow"),u(el,"href","https://huggingface.co/docs/transformers/main/model_doc/distilbert"),u(el,"rel","nofollow"),u(al,"href","https://huggingface.co/docs/transformers/main/model_doc/roberta"),u(al,"rel","nofollow"),u(tl,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/src/examples/pytorch/transformers-marianmt.html"),u(tl,"rel","nofollow"),u(Xe,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/models/models-inferentia.html#models-inferentia"),u(Xe,"rel","nofollow"),u(Ba,"id","dependencias"),u(Ba,"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(Ba,"href","#dependencias"),u(ze,"class","relative group"),u(ol,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/neuron-guide/neuron-frameworks/pytorch-neuron/index.html#installation-guide"),u(ol,"rel","nofollow"),u(sl,"href","https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-inferentia-launching.html"),u(sl,"rel","nofollow"),u(xa,"id","convertir-un-modelo-a-aws-neuron"),u(xa,"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(xa,"href","#convertir-un-modelo-a-aws-neuron"),u(Se,"class","relative group"),u(rl,"href","https://huggingface.co/docs/transformers/main/es/serialization#using-torchscript-in-python"),u(rl,"rel","nofollow"),u(pl,"href","https://awsdocs-neuron.readthedocs-hosted.com/en/latest/index.html"),u(pl,"rel","nofollow")},m(e,i){a(document.head,m),c(e,T,i),c(e,M,i),a(M,g),a(g,$),E(U,$,null),a(M,k),a(M,N),a(N,I),c(e,A,i),c(e,x,i),a(x,J),c(e,Z,i),c(e,y,i),a(y,C),a(y,X),a(X,F),a(y,Ee),a(y,se),a(se,Va),a(y,je),c(e,Pe,i),c(e,Q,i),a(Q,O),a(O,W),E(ne,W,null),a(Q,ml),a(Q,De),a(De,fl),c(e,Oa,i),c(e,V,i),a(V,hl),a(V,Pa),a(Pa,Fd),a(V,Qd),a(V,ro),a(ro,Hd),a(V,Yd),a(V,io),a(io,Kd),a(V,ep),c(e,Vr,i),c(e,Ml,i),a(Ml,ap),c(e,Or,i),c(e,Le,i),a(Le,tp),a(Le,co),a(co,lp),a(Le,op),c(e,Pr,i),c(e,yl,i),a(yl,sp),c(e,Dr,i),c(e,f,i),a(f,po),a(po,np),a(f,rp),a(f,uo),a(uo,ip),a(f,cp),a(f,mo),a(mo,dp),a(f,pp),a(f,fo),a(fo,up),a(f,mp),a(f,ho),a(ho,fp),a(f,hp),a(f,Mo),a(Mo,Mp),a(f,yp),a(f,yo),a(yo,vp),a(f,bp),a(f,vo),a(vo,Ep),a(f,jp),a(f,bo),a(bo,wp),a(f,_p),a(f,Eo),a(Eo,gp),a(f,Tp),a(f,jo),a(jo,Up),a(f,$p),a(f,wo),a(wo,Cp),a(f,Jp),a(f,_o),a(_o,Np),a(f,Ip),a(f,go),a(go,kp),a(f,Ap),a(f,To),a(To,Zp),a(f,Bp),a(f,Uo),a(Uo,xp),a(f,Wp),a(f,$o),a($o,Rp),a(f,qp),a(f,Co),a(Co,Xp),a(f,zp),a(f,Jo),a(Jo,Gp),a(f,Sp),a(f,No),a(No,Vp),a(f,Op),a(f,Io),a(Io,Pp),a(f,Dp),a(f,ko),a(ko,Lp),a(f,Fp),a(f,Ao),a(Ao,Qp),a(f,Hp),a(f,Zo),a(Zo,Yp),a(f,Kp),a(f,Bo),a(Bo,eu),a(f,au),a(f,xo),a(xo,tu),a(f,lu),a(f,Wo),a(Wo,ou),a(f,su),a(f,Ro),a(Ro,nu),a(f,ru),a(f,qo),a(qo,iu),a(f,cu),a(f,Xo),a(Xo,du),a(f,pu),a(f,zo),a(zo,uu),a(f,mu),a(f,Go),a(Go,fu),a(f,hu),a(f,So),a(So,Mu),a(f,yu),a(f,Vo),a(Vo,vu),a(f,bu),a(f,Oo),a(Oo,Eu),a(f,ju),a(f,Po),a(Po,wu),a(f,_u),a(f,Do),a(Do,gu),a(f,Tu),a(f,Lo),a(Lo,Uu),a(f,$u),a(f,Fo),a(Fo,Cu),a(f,Ju),a(f,Qo),a(Qo,Nu),a(f,Iu),a(f,Ho),a(Ho,ku),a(f,Au),a(f,Yo),a(Yo,Zu),a(f,Bu),a(f,Ko),a(Ko,xu),a(f,Wu),a(f,es),a(es,Ru),a(f,qu),a(f,as),a(as,Xu),a(f,zu),a(f,ts),a(ts,Gu),a(f,Su),a(f,ls),a(ls,Vu),a(f,Ou),a(f,os),a(os,Pu),a(f,Du),a(f,ss),a(ss,Lu),a(f,Fu),a(f,ns),a(ns,Qu),c(e,Lr,i),c(e,vl,i),a(vl,Hu),c(e,Fr,i),c(e,Fe,i),a(Fe,Da),a(Da,Yu),a(Da,rs),a(rs,Ku),a(Da,em),a(Fe,am),a(Fe,is),a(is,tm),c(e,Qr,i),c(e,we,i),a(we,Qe),a(Qe,cs),E(La,cs,null),a(we,lm),a(we,ds),a(ds,om),c(e,Hr,i),c(e,bl,i),a(bl,sm),c(e,Yr,i),E(Fa,e,i),c(e,Kr,i),c(e,He,i),a(He,nm),a(He,ps),a(ps,rm),a(He,im),c(e,ei,i),E(Qa,e,i),c(e,ai,i),c(e,El,i),a(El,cm),c(e,ti,i),E(Ha,e,i),c(e,li,i),c(e,jl,i),a(jl,dm),c(e,oi,i),E(Ya,e,i),c(e,si,i),c(e,re,i),a(re,pm),a(re,us),a(us,um),a(re,mm),a(re,ms),a(ms,fm),a(re,hm),c(e,ni,i),c(e,Y,i),a(Y,Mm),a(Y,fs),a(fs,ym),a(Y,vm),a(Y,Ka),a(Ka,bm),a(Y,Em),a(Y,et),a(et,jm),a(Y,wm),c(e,ri,i),E(at,e,i),c(e,ii,i),c(e,Ye,i),a(Ye,_m),a(Ye,hs),a(hs,gm),a(Ye,Tm),c(e,ci,i),E(tt,e,i),c(e,di,i),c(e,Ke,i),a(Ke,Um),a(Ke,lt),a(lt,$m),a(Ke,Cm),c(e,pi,i),E(ot,e,i),c(e,ui,i),c(e,wl,i),a(wl,Jm),c(e,mi,i),E(ea,e,i),c(e,fi,i),c(e,_e,i),a(_e,aa),a(aa,Ms),E(st,Ms,null),a(_e,Nm),a(_e,ys),a(ys,Im),c(e,hi,i),c(e,ta,i),a(ta,km),a(ta,vs),a(vs,Am),a(ta,Zm),c(e,Mi,i),c(e,la,i),a(la,bs),a(bs,nt),a(nt,Es),a(Es,Bm),a(nt,xm),a(nt,js),a(js,Wm),a(la,Rm),a(la,z),a(z,rt),a(rt,it),a(it,ws),a(ws,qm),a(it,Xm),a(it,_s),a(_s,zm),a(rt,Gm),a(rt,gs),a(gs,Ts),a(Ts,Sm),a(z,Vm),a(z,ct),a(ct,dt),a(dt,Us),a(Us,Om),a(dt,Pm),a(dt,$s),a($s,Dm),a(ct,Lm),a(ct,Cs),a(Cs,Js),a(Js,Fm),a(z,Qm),a(z,pt),a(pt,Ns),a(Ns,Is),a(Is,Hm),a(pt,Ym),a(pt,ks),a(ks,As),a(As,Km),a(z,ef),a(z,ut),a(ut,Zs),a(Zs,Bs),a(Bs,af),a(ut,tf),a(ut,xs),a(xs,Ws),a(Ws,lf),a(z,of),a(z,mt),a(mt,ft),a(ft,Rs),a(Rs,sf),a(ft,nf),a(ft,qs),a(qs,rf),a(mt,cf),a(mt,Xs),a(Xs,zs),a(zs,df),a(z,pf),a(z,ht),a(ht,Gs),a(Gs,Ss),a(Ss,uf),a(ht,mf),a(ht,Vs),a(Vs,Os),a(Os,ff),a(z,hf),a(z,Mt),a(Mt,Ps),a(Ps,Ds),a(Ds,Mf),a(Mt,yf),a(Mt,Ls),a(Ls,Fs),a(Fs,vf),c(e,yi,i),c(e,oa,i),a(oa,bf),a(oa,Qs),a(Qs,Ef),a(oa,jf),c(e,vi,i),E(yt,e,i),c(e,bi,i),c(e,ie,i),a(ie,wf),a(ie,Hs),a(Hs,_f),a(ie,gf),a(ie,Ys),a(Ys,Tf),a(ie,Uf),c(e,Ei,i),E(vt,e,i),c(e,ji,i),c(e,_l,i),a(_l,$f),c(e,wi,i),E(bt,e,i),c(e,_i,i),c(e,K,i),a(K,Cf),a(K,Ks),a(Ks,Jf),a(K,Nf),a(K,en),a(en,If),a(K,kf),a(K,an),a(an,Af),a(K,Zf),c(e,gi,i),E(sa,e,i),c(e,Ti,i),c(e,ge,i),a(ge,na),a(na,tn),E(Et,tn,null),a(ge,Bf),a(ge,ln),a(ln,xf),c(e,Ui,i),c(e,gl,i),a(gl,Wf),c(e,$i,i),c(e,ce,i),a(ce,on),a(on,Rf),a(ce,qf),a(ce,sn),a(sn,Xf),a(ce,zf),a(ce,nn),a(nn,Gf),c(e,Ci,i),c(e,Tl,i),a(Tl,Sf),c(e,Ji,i),c(e,Te,i),a(Te,ra),a(ra,rn),E(jt,rn,null),a(Te,Vf),a(Te,cn),a(cn,Of),c(e,Ni,i),c(e,Ul,i),a(Ul,Pf),c(e,Ii,i),c(e,de,i),a(de,ia),a(ia,Df),a(ia,dn),a(dn,Lf),a(ia,Ff),a(ia,pn),a(pn,Qf),a(de,Hf),a(de,ca),a(ca,Yf),a(ca,un),a(un,Kf),a(ca,eh),a(ca,mn),a(mn,ah),a(de,th),a(de,da),a(da,lh),a(da,fn),a(fn,oh),a(da,sh),a(da,hn),a(hn,nh),c(e,ki,i),E(pa,e,i),c(e,Ai,i),c(e,pe,i),a(pe,rh),a(pe,Mn),a(Mn,ih),a(pe,ch),a(pe,yn),a(yn,dh),a(pe,ph),c(e,Zi,i),E(wt,e,i),c(e,Bi,i),c(e,P,i),a(P,uh),a(P,vn),a(vn,mh),a(P,fh),a(P,bn),a(bn,hh),a(P,Mh),a(P,En),a(En,yh),a(P,vh),a(P,jn),a(jn,bh),a(P,Eh),c(e,xi,i),E(ua,e,i),c(e,Wi,i),c(e,$l,i),a($l,jh),c(e,Ri,i),E(_t,e,i),c(e,qi,i),c(e,Cl,i),a(Cl,wh),c(e,Xi,i),E(gt,e,i),c(e,zi,i),c(e,Jl,i),a(Jl,_h),c(e,Gi,i),E(Tt,e,i),c(e,Si,i),c(e,D,i),a(D,gh),a(D,wn),a(wn,Th),a(D,Uh),a(D,_n),a(_n,$h),a(D,Ch),a(D,gn),a(gn,Jh),a(D,Nh),a(D,Tn),a(Tn,Ih),a(D,kh),c(e,Vi,i),E(Ut,e,i),c(e,Oi,i),E(ma,e,i),c(e,Pi,i),c(e,Ue,i),a(Ue,fa),a(fa,Un),E($t,Un,null),a(Ue,Ah),a(Ue,$n),a($n,Zh),c(e,Di,i),c(e,ue,i),a(ue,Bh),a(ue,Cn),a(Cn,xh),a(ue,Wh),a(ue,Jn),a(Jn,Rh),a(ue,qh),c(e,Li,i),E(Ct,e,i),c(e,Fi,i),c(e,G,i),a(G,Xh),a(G,Nn),a(Nn,zh),a(G,Gh),a(G,In),a(In,Sh),a(G,Vh),a(G,kn),a(kn,Oh),a(G,Ph),a(G,An),a(An,Dh),a(G,Lh),a(G,Zn),a(Zn,Fh),a(G,Qh),c(e,Qi,i),E(Jt,e,i),c(e,Hi,i),E(ha,e,i),c(e,Yi,i),c(e,$e,i),a($e,Ma),a(Ma,Bn),E(Nt,Bn,null),a($e,Hh),a($e,xn),a(xn,Yh),c(e,Ki,i),c(e,me,i),a(me,Kh),a(me,Wn),a(Wn,eM),a(me,aM),a(me,Rn),a(Rn,tM),a(me,lM),c(e,ec,i),E(It,e,i),c(e,ac,i),c(e,ya,i),a(ya,oM),a(ya,qn),a(qn,sM),a(ya,nM),c(e,tc,i),c(e,Ce,i),a(Ce,va),a(va,Xn),E(kt,Xn,null),a(Ce,rM),a(Ce,zn),a(zn,iM),c(e,lc,i),c(e,Nl,i),a(Nl,cM),c(e,oc,i),c(e,fe,i),a(fe,At),a(At,dM),a(At,Gn),a(Gn,pM),a(At,uM),a(fe,mM),a(fe,Il),a(Il,fM),a(Il,Sn),a(Sn,hM),a(fe,MM),a(fe,kl),a(kl,yM),a(kl,Vn),a(Vn,vM),c(e,sc,i),c(e,ba,i),a(ba,bM),a(ba,Zt),a(Zt,EM),a(ba,jM),c(e,nc,i),c(e,Je,i),a(Je,Ea),a(Ea,On),E(Bt,On,null),a(Je,wM),a(Je,Pn),a(Pn,_M),c(e,rc,i),E(ja,e,i),c(e,ic,i),c(e,wa,i),a(wa,gM),a(wa,xt),a(xt,TM),a(wa,UM),c(e,cc,i),c(e,Al,i),a(Al,$M),c(e,dc,i),c(e,Zl,i),a(Zl,CM),c(e,pc,i),c(e,_a,i),a(_a,Dn),a(Dn,JM),a(_a,NM),a(_a,Wt),a(Wt,IM),a(Wt,Ln),a(Ln,kM),a(Wt,AM),c(e,uc,i),c(e,Bl,i),a(Bl,ZM),c(e,mc,i),c(e,Ne,i),a(Ne,ga),a(ga,Fn),E(Rt,Fn,null),a(Ne,BM),a(Ne,Qn),a(Qn,xM),c(e,fc,i),c(e,he,i),a(he,WM),a(he,Hn),a(Hn,RM),a(he,qM),a(he,Yn),a(Yn,XM),a(he,zM),c(e,hc,i),c(e,ee,i),a(ee,GM),a(ee,Kn),a(Kn,SM),a(ee,VM),a(ee,er),a(er,OM),a(ee,PM),a(ee,ar),a(ar,DM),a(ee,LM),c(e,Mc,i),c(e,Ta,i),a(Ta,FM),a(Ta,tr),a(tr,QM),a(Ta,HM),c(e,yc,i),c(e,Ie,i),a(Ie,Ua),a(Ua,lr),E(qt,lr,null),a(Ie,YM),a(Ie,or),a(or,KM),c(e,vc,i),c(e,xl,i),a(xl,ey),c(e,bc,i),c(e,Wl,i),a(Wl,ay),c(e,Ec,i),c(e,Rl,i),a(Rl,sr),a(sr,ty),c(e,jc,i),c(e,$a,i),a($a,ly),a($a,nr),a(nr,oy),a($a,sy),c(e,wc,i),c(e,ql,i),a(ql,ny),c(e,_c,i),c(e,ke,i),a(ke,Ca),a(Ca,rr),E(Xt,rr,null),a(ke,ry),a(ke,ir),a(ir,iy),c(e,gc,i),c(e,Xl,i),a(Xl,cy),c(e,Tc,i),c(e,Ae,i),a(Ae,Ja),a(Ja,cr),E(zt,cr,null),a(Ae,dy),a(Ae,dr),a(dr,py),c(e,Uc,i),c(e,H,i),a(H,uy),a(H,pr),a(pr,my),a(H,fy),a(H,ur),a(ur,hy),a(H,My),a(H,mr),a(mr,yy),a(H,vy),a(H,fr),a(fr,by),c(e,$c,i),E(Gt,e,i),c(e,Cc,i),c(e,Ze,i),a(Ze,Na),a(Na,hr),E(St,hr,null),a(Ze,Ey),a(Ze,Mr),a(Mr,jy),c(e,Jc,i),c(e,ae,i),a(ae,wy),a(ae,yr),a(yr,_y),a(ae,gy),a(ae,vr),a(vr,Ty),a(ae,Uy),a(ae,br),a(br,$y),a(ae,Cy),c(e,Nc,i),E(Vt,e,i),c(e,Ic,i),c(e,Be,i),a(Be,Ia),a(Ia,Er),E(Ot,Er,null),a(Be,Jy),a(Be,jr),a(jr,Ny),c(e,kc,i),c(e,ka,i),a(ka,Iy),a(ka,wr),a(wr,ky),a(ka,Ay),c(e,Ac,i),E(Pt,e,i),c(e,Zc,i),c(e,xe,i),a(xe,Aa),a(Aa,_r),E(Dt,_r,null),a(xe,Zy),a(xe,gr),a(gr,By),c(e,Bc,i),c(e,Me,i),a(Me,xy),a(Me,Lt),a(Lt,Wy),a(Me,Ry),a(Me,Ft),a(Ft,qy),a(Me,Xy),c(e,xc,i),c(e,ye,i),a(ye,Tr),a(Tr,zy),a(ye,Gy),a(ye,zl),a(zl,Sy),a(zl,Qt),a(Qt,Vy),a(ye,Oy),a(ye,We),a(We,Py),a(We,Ht),a(Ht,Dy),a(We,Ly),a(We,Yt),a(Yt,Fy),a(We,Qy),c(e,Wc,i),c(e,Re,i),a(Re,Za),a(Za,Ur),E(Kt,Ur,null),a(Re,Hy),a(Re,$r),a($r,Yy),c(e,Rc,i),c(e,S,i),a(S,Ky),a(S,qe),a(qe,ev),a(qe,Cr),a(Cr,av),a(qe,tv),a(S,lv),a(S,el),a(el,ov),a(S,sv),a(S,al),a(al,nv),a(S,rv),a(S,tl),a(tl,iv),a(S,cv),a(S,Xe),a(Xe,dv),a(Xe,Jr),a(Jr,pv),a(Xe,uv),a(S,mv),c(e,qc,i),c(e,ze,i),a(ze,Ba),a(Ba,Nr),E(ll,Nr,null),a(ze,fv),a(ze,Ir),a(Ir,hv),c(e,Xc,i),c(e,Gl,i),a(Gl,Mv),c(e,zc,i),c(e,Sl,i),a(Sl,Ge),a(Ge,yv),a(Ge,ol),a(ol,vv),a(Ge,bv),a(Ge,sl),a(sl,Ev),a(Ge,jv),c(e,Gc,i),c(e,Se,i),a(Se,xa),a(xa,kr),E(nl,kr,null),a(Se,wv),a(Se,Ar),a(Ar,_v),c(e,Sc,i),c(e,te,i),a(te,gv),a(te,rl),a(rl,Tv),a(te,Uv),a(te,Zr),a(Zr,$v),a(te,Cv),a(te,Br),a(Br,Jv),a(te,Nv),c(e,Vc,i),E(il,e,i),c(e,Oc,i),c(e,Vl,i),a(Vl,Iv),c(e,Pc,i),E(cl,e,i),c(e,Dc,i),c(e,Ol,i),a(Ol,kv),c(e,Lc,i),E(dl,e,i),c(e,Fc,i),c(e,Pl,i),a(Pl,Av),c(e,Qc,i),c(e,Wa,i),a(Wa,Zv),a(Wa,pl),a(pl,Bv),a(Wa,xv),Hc=!0},p(e,[i]){const ul={};i&2&&(ul.$$scope={dirty:i,ctx:e}),ea.$set(ul);const xr={};i&2&&(xr.$$scope={dirty:i,ctx:e}),sa.$set(xr);const Wr={};i&2&&(Wr.$$scope={dirty:i,ctx:e}),pa.$set(Wr);const Rr={};i&2&&(Rr.$$scope={dirty:i,ctx:e}),ua.$set(Rr);const qr={};i&2&&(qr.$$scope={dirty:i,ctx:e}),ma.$set(qr);const Ve={};i&2&&(Ve.$$scope={dirty:i,ctx:e}),ha.$set(Ve);const Xr={};i&2&&(Xr.$$scope={dirty:i,ctx:e}),ja.$set(Xr)},i(e){Hc||(j(U.$$.fragment,e),j(ne.$$.fragment,e),j(La.$$.fragment,e),j(Fa.$$.fragment,e),j(Qa.$$.fragment,e),j(Ha.$$.fragment,e),j(Ya.$$.fragment,e),j(at.$$.fragment,e),j(tt.$$.fragment,e),j(ot.$$.fragment,e),j(ea.$$.fragment,e),j(st.$$.fragment,e),j(yt.$$.fragment,e),j(vt.$$.fragment,e),j(bt.$$.fragment,e),j(sa.$$.fragment,e),j(Et.$$.fragment,e),j(jt.$$.fragment,e),j(pa.$$.fragment,e),j(wt.$$.fragment,e),j(ua.$$.fragment,e),j(_t.$$.fragment,e),j(gt.$$.fragment,e),j(Tt.$$.fragment,e),j(Ut.$$.fragment,e),j(ma.$$.fragment,e),j($t.$$.fragment,e),j(Ct.$$.fragment,e),j(Jt.$$.fragment,e),j(ha.$$.fragment,e),j(Nt.$$.fragment,e),j(It.$$.fragment,e),j(kt.$$.fragment,e),j(Bt.$$.fragment,e),j(ja.$$.fragment,e),j(Rt.$$.fragment,e),j(qt.$$.fragment,e),j(Xt.$$.fragment,e),j(zt.$$.fragment,e),j(Gt.$$.fragment,e),j(St.$$.fragment,e),j(Vt.$$.fragment,e),j(Ot.$$.fragment,e),j(Pt.$$.fragment,e),j(Dt.$$.fragment,e),j(Kt.$$.fragment,e),j(ll.$$.fragment,e),j(nl.$$.fragment,e),j(il.$$.fragment,e),j(cl.$$.fragment,e),j(dl.$$.fragment,e),Hc=!0)},o(e){w(U.$$.fragment,e),w(ne.$$.fragment,e),w(La.$$.fragment,e),w(Fa.$$.fragment,e),w(Qa.$$.fragment,e),w(Ha.$$.fragment,e),w(Ya.$$.fragment,e),w(at.$$.fragment,e),w(tt.$$.fragment,e),w(ot.$$.fragment,e),w(ea.$$.fragment,e),w(st.$$.fragment,e),w(yt.$$.fragment,e),w(vt.$$.fragment,e),w(bt.$$.fragment,e),w(sa.$$.fragment,e),w(Et.$$.fragment,e),w(jt.$$.fragment,e),w(pa.$$.fragment,e),w(wt.$$.fragment,e),w(ua.$$.fragment,e),w(_t.$$.fragment,e),w(gt.$$.fragment,e),w(Tt.$$.fragment,e),w(Ut.$$.fragment,e),w(ma.$$.fragment,e),w($t.$$.fragment,e),w(Ct.$$.fragment,e),w(Jt.$$.fragment,e),w(ha.$$.fragment,e),w(Nt.$$.fragment,e),w(It.$$.fragment,e),w(kt.$$.fragment,e),w(Bt.$$.fragment,e),w(ja.$$.fragment,e),w(Rt.$$.fragment,e),w(qt.$$.fragment,e),w(Xt.$$.fragment,e),w(zt.$$.fragment,e),w(Gt.$$.fragment,e),w(St.$$.fragment,e),w(Vt.$$.fragment,e),w(Ot.$$.fragment,e),w(Pt.$$.fragment,e),w(Dt.$$.fragment,e),w(Kt.$$.fragment,e),w(ll.$$.fragment,e),w(nl.$$.fragment,e),w(il.$$.fragment,e),w(cl.$$.fragment,e),w(dl.$$.fragment,e),Hc=!1},d(e){t(m),e&&t(T),e&&t(M),_(U),e&&t(A),e&&t(x),e&&t(Z),e&&t(y),e&&t(Pe),e&&t(Q),_(ne),e&&t(Oa),e&&t(V),e&&t(Vr),e&&t(Ml),e&&t(Or),e&&t(Le),e&&t(Pr),e&&t(yl),e&&t(Dr),e&&t(f),e&&t(Lr),e&&t(vl),e&&t(Fr),e&&t(Fe),e&&t(Qr),e&&t(we),_(La),e&&t(Hr),e&&t(bl),e&&t(Yr),_(Fa,e),e&&t(Kr),e&&t(He),e&&t(ei),_(Qa,e),e&&t(ai),e&&t(El),e&&t(ti),_(Ha,e),e&&t(li),e&&t(jl),e&&t(oi),_(Ya,e),e&&t(si),e&&t(re),e&&t(ni),e&&t(Y),e&&t(ri),_(at,e),e&&t(ii),e&&t(Ye),e&&t(ci),_(tt,e),e&&t(di),e&&t(Ke),e&&t(pi),_(ot,e),e&&t(ui),e&&t(wl),e&&t(mi),_(ea,e),e&&t(fi),e&&t(_e),_(st),e&&t(hi),e&&t(ta),e&&t(Mi),e&&t(la),e&&t(yi),e&&t(oa),e&&t(vi),_(yt,e),e&&t(bi),e&&t(ie),e&&t(Ei),_(vt,e),e&&t(ji),e&&t(_l),e&&t(wi),_(bt,e),e&&t(_i),e&&t(K),e&&t(gi),_(sa,e),e&&t(Ti),e&&t(ge),_(Et),e&&t(Ui),e&&t(gl),e&&t($i),e&&t(ce),e&&t(Ci),e&&t(Tl),e&&t(Ji),e&&t(Te),_(jt),e&&t(Ni),e&&t(Ul),e&&t(Ii),e&&t(de),e&&t(ki),_(pa,e),e&&t(Ai),e&&t(pe),e&&t(Zi),_(wt,e),e&&t(Bi),e&&t(P),e&&t(xi),_(ua,e),e&&t(Wi),e&&t($l),e&&t(Ri),_(_t,e),e&&t(qi),e&&t(Cl),e&&t(Xi),_(gt,e),e&&t(zi),e&&t(Jl),e&&t(Gi),_(Tt,e),e&&t(Si),e&&t(D),e&&t(Vi),_(Ut,e),e&&t(Oi),_(ma,e),e&&t(Pi),e&&t(Ue),_($t),e&&t(Di),e&&t(ue),e&&t(Li),_(Ct,e),e&&t(Fi),e&&t(G),e&&t(Qi),_(Jt,e),e&&t(Hi),_(ha,e),e&&t(Yi),e&&t($e),_(Nt),e&&t(Ki),e&&t(me),e&&t(ec),_(It,e),e&&t(ac),e&&t(ya),e&&t(tc),e&&t(Ce),_(kt),e&&t(lc),e&&t(Nl),e&&t(oc),e&&t(fe),e&&t(sc),e&&t(ba),e&&t(nc),e&&t(Je),_(Bt),e&&t(rc),_(ja,e),e&&t(ic),e&&t(wa),e&&t(cc),e&&t(Al),e&&t(dc),e&&t(Zl),e&&t(pc),e&&t(_a),e&&t(uc),e&&t(Bl),e&&t(mc),e&&t(Ne),_(Rt),e&&t(fc),e&&t(he),e&&t(hc),e&&t(ee),e&&t(Mc),e&&t(Ta),e&&t(yc),e&&t(Ie),_(qt),e&&t(vc),e&&t(xl),e&&t(bc),e&&t(Wl),e&&t(Ec),e&&t(Rl),e&&t(jc),e&&t($a),e&&t(wc),e&&t(ql),e&&t(_c),e&&t(ke),_(Xt),e&&t(gc),e&&t(Xl),e&&t(Tc),e&&t(Ae),_(zt),e&&t(Uc),e&&t(H),e&&t($c),_(Gt,e),e&&t(Cc),e&&t(Ze),_(St),e&&t(Jc),e&&t(ae),e&&t(Nc),_(Vt,e),e&&t(Ic),e&&t(Be),_(Ot),e&&t(kc),e&&t(ka),e&&t(Ac),_(Pt,e),e&&t(Zc),e&&t(xe),_(Dt),e&&t(Bc),e&&t(Me),e&&t(xc),e&&t(ye),e&&t(Wc),e&&t(Re),_(Kt),e&&t(Rc),e&&t(S),e&&t(qc),e&&t(ze),_(ll),e&&t(Xc),e&&t(Gl),e&&t(zc),e&&t(Sl),e&&t(Gc),e&&t(Se),_(nl),e&&t(Sc),e&&t(te),e&&t(Vc),_(il,e),e&&t(Oc),e&&t(Vl),e&&t(Pc),_(cl,e),e&&t(Dc),e&&t(Ol),e&&t(Lc),_(dl,e),e&&t(Fc),e&&t(Pl),e&&t(Qc),e&&t(Wa)}}}const P1={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 D1(R){return A1(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class ew extends J1{constructor(m){super();N1(this,m,D1,O1,I1,{})}}export{ew as default,P1 as metadata};
