import{S as Wr,i as Xr,s as Zr,e as r,k as d,w as f,t as n,M as eo,c as o,d as s,m as i,a as u,x as b,h as l,b as y,G as a,g as p,y as h,q as j,o as _,B as w,v as so}from"../chunks/vendor-hf-doc-builder.js";import{T as Tt}from"../chunks/Tip-hf-doc-builder.js";import{I as un}from"../chunks/IconCopyLink-hf-doc-builder.js";import{C as P}from"../chunks/CodeBlock-hf-doc-builder.js";function ao(K){let c,D;return{c(){c=r("p"),D=n("Esta funci\xF3n est\xE1 disponible actualmente s\xF3lo para PyTorch.")},l(m){c=o(m,"P",{});var v=u(c);D=l(v,"Esta funci\xF3n est\xE1 disponible actualmente s\xF3lo para PyTorch."),v.forEach(s)},m(m,v){p(m,c,v),a(c,D)},d(m){m&&s(c)}}}function no(K){let c,D,m,v,C;return{c(){c=r("p"),D=n("Para el entrenamiento multi-GPU, requiere DDP ("),m=r("code"),v=n("torch.distributed.launch"),C=n(").")},l($){c=o($,"P",{});var E=u(c);D=l(E,"Para el entrenamiento multi-GPU, requiere DDP ("),m=o(E,"CODE",{});var N=u(m);v=l(N,"torch.distributed.launch"),N.forEach(s),C=l(E,")."),E.forEach(s)},m($,E){p($,c,E),a(c,D),a(c,m),a(m,v),a(c,C)},d($){$&&s(c)}}}function lo(K){let c,D,m,v,C;return{c(){c=r("p"),D=n("Esta funci\xF3n puede utilizarse con cualquier modelo basado en "),m=r("code"),v=n("nn.Module"),C=n(".")},l($){c=o($,"P",{});var E=u(c);D=l(E,"Esta funci\xF3n puede utilizarse con cualquier modelo basado en "),m=o(E,"CODE",{});var N=u(m);v=l(N,"nn.Module"),N.forEach(s),C=l(E,"."),E.forEach(s)},m($,E){p($,c,E),a(c,D),a(c,m),a(m,v),a(c,C)},d($){$&&s(c)}}}function to(K){let c,D,m,v,C,$,E,N,dn,Vs,S,B,Je,ie,cn,Qe,mn,Ys,H,fn,We,bn,hn,Js,ce,Qs,Oe,jn,Ws,me,Xs,Le,_n,Zs,xe,wn,ea,Te,vn,sa,V,gn,Xe,$n,yn,aa,fe,na,Ue,En,la,F,Y,Ze,be,Dn,es,qn,ta,J,ra,Q,oa,W,pa,L,kn,ss,Pn,Cn,as,On,Ln,ns,xn,Tn,ua,X,Un,ls,zn,Gn,da,he,ia,A,Nn,ts,An,Rn,rs,Sn,Fn,ca,ze,Mn,ma,je,fa,O,os,In,Kn,ps,Bn,Hn,us,Vn,Yn,ds,Jn,Qn,ba,_e,ha,Ge,Wn,ja,g,Xn,is,Zn,el,cs,sl,al,ms,nl,ll,fs,tl,rl,bs,ol,pl,hs,ul,dl,js,il,cl,_a,Z,ml,_s,fl,bl,wa,Ne,hl,va,we,ga,x,jl,ws,_l,wl,vs,vl,gl,gs,$l,yl,$a,Ae,El,ya,ve,Ea,q,Dl,$s,ql,kl,ys,Pl,Cl,Es,Ol,Ll,Ds,xl,Tl,qs,Ul,zl,Da,T,Gl,ks,Nl,Al,Ps,Rl,Sl,Cs,Fl,Ml,qa,Re,Il,ka,ee,Kl,Os,Bl,Hl,Pa,ge,Ca,se,Vl,Ls,Yl,Jl,Oa,ae,Ql,xs,Wl,Xl,La,U,Zl,Ts,et,st,Us,at,nt,zs,lt,tt,xa,$e,Ta,R,rt,Gs,ot,pt,Ns,ut,dt,Ua,ye,za,z,it,As,ct,mt,Rs,ft,bt,Ss,ht,jt,Ga,ne,_t,Fs,wt,vt,Na,Se,gt,Aa,Ee,Ra,M,le,Ms,De,$t,Is,yt,Sa,Fe,Et,Fa,te,Dt,Ks,qt,kt,Ma,qe,Ia,Me,Pt,Ka,Ie,Ct,Ba,Ke,Ot,Ha,ke,Va,Be,Lt,Ya,He,xt,Ja,Pe,Qa;return $=new un({}),ie=new un({}),ce=new P({props:{code:"wget https://raw.githubusercontent.com/huggingface/transformers/main/scripts/distributed/torch-distributed-gpu-test.py",highlighted:"wget https://raw.githubusercontent.com/huggingface/transformers/main/scripts/distributed/torch-distributed-gpu-test.py"}}),me=new P({props:{code:"python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py",highlighted:"python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py"}}),fe=new P({props:{code:"NCCL_DEBUG=INFO python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py",highlighted:"NCCL_DEBUG=INFO python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py"}}),be=new un({}),J=new Tt({props:{$$slots:{default:[ao]},$$scope:{ctx:K}}}),Q=new Tt({props:{$$slots:{default:[no]},$$scope:{ctx:K}}}),W=new Tt({props:{$$slots:{default:[lo]},$$scope:{ctx:K}}}),he=new P({props:{code:"--debug underflow_overflow",highlighted:"--debug underflow_overflow"}}),je=new P({props:{code:`from .debug_utils import DebugUnderflowOverflow

debug_overflow = DebugUnderflowOverflow(model)`,highlighted:`<span class="hljs-keyword">from</span> .debug_utils <span class="hljs-keyword">import</span> DebugUnderflowOverflow

debug_overflow = DebugUnderflowOverflow(model)`}}),_e=new P({props:{code:`Detected inf/nan during batch_number=0
Last 21 forward frames:
abs min  abs max  metadata
                  encoder.block.1.layer.1.DenseReluDense.dropout Dropout
0.00e+00 2.57e+02 input[0]
0.00e+00 2.85e+02 output
[...]
                  encoder.block.2.layer.0 T5LayerSelfAttention
6.78e-04 3.15e+03 input[0]
2.65e-04 3.42e+03 output[0]
             None output[1]
2.25e-01 1.00e+04 output[2]
                  encoder.block.2.layer.1.layer_norm T5LayerNorm
8.69e-02 4.18e-01 weight
2.65e-04 3.42e+03 input[0]
1.79e-06 4.65e+00 output
                  encoder.block.2.layer.1.DenseReluDense.wi_0 Linear
2.17e-07 4.50e+00 weight
1.79e-06 4.65e+00 input[0]
2.68e-06 3.70e+01 output
                  encoder.block.2.layer.1.DenseReluDense.wi_1 Linear
8.08e-07 2.66e+01 weight
1.79e-06 4.65e+00 input[0]
1.27e-04 2.37e+02 output
                  encoder.block.2.layer.1.DenseReluDense.dropout Dropout
0.00e+00 8.76e+03 input[0]
0.00e+00 9.74e+03 output
                  encoder.block.2.layer.1.DenseReluDense.wo Linear
1.01e-06 6.44e+00 weight
0.00e+00 9.74e+03 input[0]
3.18e-04 6.27e+04 output
                  encoder.block.2.layer.1.DenseReluDense T5DenseGatedGeluDense
1.79e-06 4.65e+00 input[0]
3.18e-04 6.27e+04 output
                  encoder.block.2.layer.1.dropout Dropout
3.18e-04 6.27e+04 input[0]
0.00e+00      inf output`,highlighted:`<span class="hljs-attribute">Detected</span> inf/nan during batch_number=<span class="hljs-number">0</span>
<span class="hljs-attribute">Last</span> <span class="hljs-number">21</span> forward frames:
<span class="hljs-attribute">abs</span> min  abs max  metadata
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">1</span>.layer.<span class="hljs-number">1</span>.DenseReluDense.dropout Dropout
<span class="hljs-attribute">0</span>.<span class="hljs-number">00</span>e+<span class="hljs-number">00</span> <span class="hljs-number">2</span>.<span class="hljs-number">57</span>e+<span class="hljs-number">02</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">0</span>.<span class="hljs-number">00</span>e+<span class="hljs-number">00</span> <span class="hljs-number">2</span>.<span class="hljs-number">85</span>e+<span class="hljs-number">02</span> output<span class="hljs-meta">
[...]</span>
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">0</span> T5LayerSelfAttention
<span class="hljs-attribute">6</span>.<span class="hljs-number">78</span>e-<span class="hljs-number">04</span> <span class="hljs-number">3</span>.<span class="hljs-number">15</span>e+<span class="hljs-number">03</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">2</span>.<span class="hljs-number">65</span>e-<span class="hljs-number">04</span> <span class="hljs-number">3</span>.<span class="hljs-number">42</span>e+<span class="hljs-number">03</span> output[<span class="hljs-number">0</span>]
             <span class="hljs-attribute">None</span> output[<span class="hljs-number">1</span>]
<span class="hljs-attribute">2</span>.<span class="hljs-number">25</span>e-<span class="hljs-number">01</span> <span class="hljs-number">1</span>.<span class="hljs-number">00</span>e+<span class="hljs-number">04</span> output[<span class="hljs-number">2</span>]
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">1</span>.layer_norm T5LayerNorm
<span class="hljs-attribute">8</span>.<span class="hljs-number">69</span>e-<span class="hljs-number">02</span> <span class="hljs-number">4</span>.<span class="hljs-number">18</span>e-<span class="hljs-number">01</span> weight
<span class="hljs-attribute">2</span>.<span class="hljs-number">65</span>e-<span class="hljs-number">04</span> <span class="hljs-number">3</span>.<span class="hljs-number">42</span>e+<span class="hljs-number">03</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">1</span>.<span class="hljs-number">79</span>e-<span class="hljs-number">06</span> <span class="hljs-number">4</span>.<span class="hljs-number">65</span>e+<span class="hljs-number">00</span> output
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">1</span>.DenseReluDense.wi_0 Linear
<span class="hljs-attribute">2</span>.<span class="hljs-number">17</span>e-<span class="hljs-number">07</span> <span class="hljs-number">4</span>.<span class="hljs-number">50</span>e+<span class="hljs-number">00</span> weight
<span class="hljs-attribute">1</span>.<span class="hljs-number">79</span>e-<span class="hljs-number">06</span> <span class="hljs-number">4</span>.<span class="hljs-number">65</span>e+<span class="hljs-number">00</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">2</span>.<span class="hljs-number">68</span>e-<span class="hljs-number">06</span> <span class="hljs-number">3</span>.<span class="hljs-number">70</span>e+<span class="hljs-number">01</span> output
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">1</span>.DenseReluDense.wi_1 Linear
<span class="hljs-attribute">8</span>.<span class="hljs-number">08</span>e-<span class="hljs-number">07</span> <span class="hljs-number">2</span>.<span class="hljs-number">66</span>e+<span class="hljs-number">01</span> weight
<span class="hljs-attribute">1</span>.<span class="hljs-number">79</span>e-<span class="hljs-number">06</span> <span class="hljs-number">4</span>.<span class="hljs-number">65</span>e+<span class="hljs-number">00</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">1</span>.<span class="hljs-number">27</span>e-<span class="hljs-number">04</span> <span class="hljs-number">2</span>.<span class="hljs-number">37</span>e+<span class="hljs-number">02</span> output
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">1</span>.DenseReluDense.dropout Dropout
<span class="hljs-attribute">0</span>.<span class="hljs-number">00</span>e+<span class="hljs-number">00</span> <span class="hljs-number">8</span>.<span class="hljs-number">76</span>e+<span class="hljs-number">03</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">0</span>.<span class="hljs-number">00</span>e+<span class="hljs-number">00</span> <span class="hljs-number">9</span>.<span class="hljs-number">74</span>e+<span class="hljs-number">03</span> output
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">1</span>.DenseReluDense.wo Linear
<span class="hljs-attribute">1</span>.<span class="hljs-number">01</span>e-<span class="hljs-number">06</span> <span class="hljs-number">6</span>.<span class="hljs-number">44</span>e+<span class="hljs-number">00</span> weight
<span class="hljs-attribute">0</span>.<span class="hljs-number">00</span>e+<span class="hljs-number">00</span> <span class="hljs-number">9</span>.<span class="hljs-number">74</span>e+<span class="hljs-number">03</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">3</span>.<span class="hljs-number">18</span>e-<span class="hljs-number">04</span> <span class="hljs-number">6</span>.<span class="hljs-number">27</span>e+<span class="hljs-number">04</span> output
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">1</span>.DenseReluDense T5DenseGatedGeluDense
<span class="hljs-attribute">1</span>.<span class="hljs-number">79</span>e-<span class="hljs-number">06</span> <span class="hljs-number">4</span>.<span class="hljs-number">65</span>e+<span class="hljs-number">00</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">3</span>.<span class="hljs-number">18</span>e-<span class="hljs-number">04</span> <span class="hljs-number">6</span>.<span class="hljs-number">27</span>e+<span class="hljs-number">04</span> output
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">1</span>.dropout Dropout
<span class="hljs-attribute">3</span>.<span class="hljs-number">18</span>e-<span class="hljs-number">04</span> <span class="hljs-number">6</span>.<span class="hljs-number">27</span>e+<span class="hljs-number">04</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">0</span>.<span class="hljs-number">00</span>e+<span class="hljs-number">00</span>      inf output`}}),we=new P({props:{code:`                  encoder.block.2.layer.1.layer_norm T5LayerNorm
8.69e-02 4.18e-01 weight
2.65e-04 3.42e+03 input[0]
1.79e-06 4.65e+00 output`,highlighted:`                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">1</span>.layer_norm T5LayerNorm
<span class="hljs-attribute">8</span>.<span class="hljs-number">69</span>e-<span class="hljs-number">02</span> <span class="hljs-number">4</span>.<span class="hljs-number">18</span>e-<span class="hljs-number">01</span> weight
<span class="hljs-attribute">2</span>.<span class="hljs-number">65</span>e-<span class="hljs-number">04</span> <span class="hljs-number">3</span>.<span class="hljs-number">42</span>e+<span class="hljs-number">03</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">1</span>.<span class="hljs-number">79</span>e-<span class="hljs-number">06</span> <span class="hljs-number">4</span>.<span class="hljs-number">65</span>e+<span class="hljs-number">00</span> output`}}),ve=new P({props:{code:`Detected inf/nan during batch_number=0
Last 21 forward frames:
abs min  abs max  metadata
[...]
                  encoder.block.2.layer.1.DenseReluDense.wi_0 Linear
2.17e-07 4.50e+00 weight
1.79e-06 4.65e+00 input[0]
2.68e-06 3.70e+01 output
                  encoder.block.2.layer.1.DenseReluDense.wi_1 Linear
8.08e-07 2.66e+01 weight
1.79e-06 4.65e+00 input[0]
1.27e-04 2.37e+02 output
                  encoder.block.2.layer.1.DenseReluDense.wo Linear
1.01e-06 6.44e+00 weight
0.00e+00 9.74e+03 input[0]
3.18e-04 6.27e+04 output
                  encoder.block.2.layer.1.DenseReluDense T5DenseGatedGeluDense
1.79e-06 4.65e+00 input[0]
3.18e-04 6.27e+04 output
                  encoder.block.2.layer.1.dropout Dropout
3.18e-04 6.27e+04 input[0]
0.00e+00      inf output`,highlighted:`<span class="hljs-attribute">Detected</span> inf/nan during batch_number=<span class="hljs-number">0</span>
<span class="hljs-attribute">Last</span> <span class="hljs-number">21</span> forward frames:
<span class="hljs-attribute">abs</span> min  abs max  metadata<span class="hljs-meta">
[...]</span>
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">1</span>.DenseReluDense.wi_0 Linear
<span class="hljs-attribute">2</span>.<span class="hljs-number">17</span>e-<span class="hljs-number">07</span> <span class="hljs-number">4</span>.<span class="hljs-number">50</span>e+<span class="hljs-number">00</span> weight
<span class="hljs-attribute">1</span>.<span class="hljs-number">79</span>e-<span class="hljs-number">06</span> <span class="hljs-number">4</span>.<span class="hljs-number">65</span>e+<span class="hljs-number">00</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">2</span>.<span class="hljs-number">68</span>e-<span class="hljs-number">06</span> <span class="hljs-number">3</span>.<span class="hljs-number">70</span>e+<span class="hljs-number">01</span> output
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">1</span>.DenseReluDense.wi_1 Linear
<span class="hljs-attribute">8</span>.<span class="hljs-number">08</span>e-<span class="hljs-number">07</span> <span class="hljs-number">2</span>.<span class="hljs-number">66</span>e+<span class="hljs-number">01</span> weight
<span class="hljs-attribute">1</span>.<span class="hljs-number">79</span>e-<span class="hljs-number">06</span> <span class="hljs-number">4</span>.<span class="hljs-number">65</span>e+<span class="hljs-number">00</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">1</span>.<span class="hljs-number">27</span>e-<span class="hljs-number">04</span> <span class="hljs-number">2</span>.<span class="hljs-number">37</span>e+<span class="hljs-number">02</span> output
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">1</span>.DenseReluDense.wo Linear
<span class="hljs-attribute">1</span>.<span class="hljs-number">01</span>e-<span class="hljs-number">06</span> <span class="hljs-number">6</span>.<span class="hljs-number">44</span>e+<span class="hljs-number">00</span> weight
<span class="hljs-attribute">0</span>.<span class="hljs-number">00</span>e+<span class="hljs-number">00</span> <span class="hljs-number">9</span>.<span class="hljs-number">74</span>e+<span class="hljs-number">03</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">3</span>.<span class="hljs-number">18</span>e-<span class="hljs-number">04</span> <span class="hljs-number">6</span>.<span class="hljs-number">27</span>e+<span class="hljs-number">04</span> output
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">1</span>.DenseReluDense T5DenseGatedGeluDense
<span class="hljs-attribute">1</span>.<span class="hljs-number">79</span>e-<span class="hljs-number">06</span> <span class="hljs-number">4</span>.<span class="hljs-number">65</span>e+<span class="hljs-number">00</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">3</span>.<span class="hljs-number">18</span>e-<span class="hljs-number">04</span> <span class="hljs-number">6</span>.<span class="hljs-number">27</span>e+<span class="hljs-number">04</span> output
                  <span class="hljs-attribute">encoder</span>.block.<span class="hljs-number">2</span>.layer.<span class="hljs-number">1</span>.dropout Dropout
<span class="hljs-attribute">3</span>.<span class="hljs-number">18</span>e-<span class="hljs-number">04</span> <span class="hljs-number">6</span>.<span class="hljs-number">27</span>e+<span class="hljs-number">04</span> input[<span class="hljs-number">0</span>]
<span class="hljs-attribute">0</span>.<span class="hljs-number">00</span>e+<span class="hljs-number">00</span>      inf output`}}),ge=new P({props:{code:`class T5DenseGatedGeluDense(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.wi_0 = nn.Linear(config.d_model, config.d_ff, bias=False)
        self.wi_1 = nn.Linear(config.d_model, config.d_ff, bias=False)
        self.wo = nn.Linear(config.d_ff, config.d_model, bias=False)
        self.dropout = nn.Dropout(config.dropout_rate)
        self.gelu_act = ACT2FN["gelu_new"]

    def forward(self, hidden_states):
        hidden_gelu = self.gelu_act(self.wi_0(hidden_states))
        hidden_linear = self.wi_1(hidden_states)
        hidden_states = hidden_gelu * hidden_linear
        hidden_states = self.dropout(hidden_states)
        hidden_states = self.wo(hidden_states)
        return hidden_states`,highlighted:`<span class="hljs-keyword">class</span> <span class="hljs-title class_">T5DenseGatedGeluDense</span>(nn.Module):
    <span class="hljs-keyword">def</span> <span class="hljs-title function_">__init__</span>(<span class="hljs-params">self, config</span>):
        <span class="hljs-built_in">super</span>().__init__()
        self.wi_0 = nn.Linear(config.d_model, config.d_ff, bias=<span class="hljs-literal">False</span>)
        self.wi_1 = nn.Linear(config.d_model, config.d_ff, bias=<span class="hljs-literal">False</span>)
        self.wo = nn.Linear(config.d_ff, config.d_model, bias=<span class="hljs-literal">False</span>)
        self.dropout = nn.Dropout(config.dropout_rate)
        self.gelu_act = ACT2FN[<span class="hljs-string">&quot;gelu_new&quot;</span>]

    <span class="hljs-keyword">def</span> <span class="hljs-title function_">forward</span>(<span class="hljs-params">self, hidden_states</span>):
        hidden_gelu = self.gelu_act(self.wi_0(hidden_states))
        hidden_linear = self.wi_1(hidden_states)
        hidden_states = hidden_gelu * hidden_linear
        hidden_states = self.dropout(hidden_states)
        hidden_states = self.wo(hidden_states)
        <span class="hljs-keyword">return</span> hidden_states`}}),$e=new P({props:{code:`def _forward(self, hidden_states):
    hidden_gelu = self.gelu_act(self.wi_0(hidden_states))
    hidden_linear = self.wi_1(hidden_states)
    hidden_states = hidden_gelu * hidden_linear
    hidden_states = self.dropout(hidden_states)
    hidden_states = self.wo(hidden_states)
    return hidden_states


import torch


def forward(self, hidden_states):
    if torch.is_autocast_enabled():
        with torch.cuda.amp.autocast(enabled=False):
            return self._forward(hidden_states)
    else:
        return self._forward(hidden_states)`,highlighted:`<span class="hljs-keyword">def</span> <span class="hljs-title function_">_forward</span>(<span class="hljs-params">self, hidden_states</span>):
    hidden_gelu = self.gelu_act(self.wi_0(hidden_states))
    hidden_linear = self.wi_1(hidden_states)
    hidden_states = hidden_gelu * hidden_linear
    hidden_states = self.dropout(hidden_states)
    hidden_states = self.wo(hidden_states)
    <span class="hljs-keyword">return</span> hidden_states


<span class="hljs-keyword">import</span> torch


<span class="hljs-keyword">def</span> <span class="hljs-title function_">forward</span>(<span class="hljs-params">self, hidden_states</span>):
    <span class="hljs-keyword">if</span> torch.is_autocast_enabled():
        <span class="hljs-keyword">with</span> torch.cuda.amp.autocast(enabled=<span class="hljs-literal">False</span>):
            <span class="hljs-keyword">return</span> self._forward(hidden_states)
    <span class="hljs-keyword">else</span>:
        <span class="hljs-keyword">return</span> self._forward(hidden_states)`}}),ye=new P({props:{code:`from debug_utils import detect_overflow


class T5LayerFF(nn.Module):
    [...]

    def forward(self, hidden_states):
        forwarded_states = self.layer_norm(hidden_states)
        detect_overflow(forwarded_states, "after layer_norm")
        forwarded_states = self.DenseReluDense(forwarded_states)
        detect_overflow(forwarded_states, "after DenseReluDense")
        return hidden_states + self.dropout(forwarded_states)`,highlighted:`<span class="hljs-keyword">from</span> debug_utils <span class="hljs-keyword">import</span> detect_overflow


<span class="hljs-keyword">class</span> <span class="hljs-title class_">T5LayerFF</span>(nn.Module):
    [...]

    <span class="hljs-keyword">def</span> <span class="hljs-title function_">forward</span>(<span class="hljs-params">self, hidden_states</span>):
        forwarded_states = self.layer_norm(hidden_states)
        detect_overflow(forwarded_states, <span class="hljs-string">&quot;after layer_norm&quot;</span>)
        forwarded_states = self.DenseReluDense(forwarded_states)
        detect_overflow(forwarded_states, <span class="hljs-string">&quot;after DenseReluDense&quot;</span>)
        <span class="hljs-keyword">return</span> hidden_states + self.dropout(forwarded_states)`}}),Ee=new P({props:{code:`from .debug_utils import DebugUnderflowOverflow

debug_overflow = DebugUnderflowOverflow(model, max_frames_to_save=100)`,highlighted:`<span class="hljs-keyword">from</span> .debug_utils <span class="hljs-keyword">import</span> DebugUnderflowOverflow

debug_overflow = DebugUnderflowOverflow(model, max_frames_to_save=<span class="hljs-number">100</span>)`}}),De=new un({}),qe=new P({props:{code:"debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[1, 3])",highlighted:'debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[<span class="hljs-number">1</span>, <span class="hljs-number">3</span>])'}}),ke=new P({props:{code:`                  *** Starting batch number=1 ***
abs min  abs max  metadata
                  shared Embedding
1.01e-06 7.92e+02 weight
0.00e+00 2.47e+04 input[0]
5.36e-05 7.92e+02 output
[...]
                  decoder.dropout Dropout
1.60e-07 2.27e+01 input[0]
0.00e+00 2.52e+01 output
                  decoder T5Stack
     not a tensor output
                  lm_head Linear
1.01e-06 7.92e+02 weight
0.00e+00 1.11e+00 input[0]
6.06e-02 8.39e+01 output
                   T5ForConditionalGeneration
     not a tensor output

                  *** Starting batch number=3 ***
abs min  abs max  metadata
                  shared Embedding
1.01e-06 7.92e+02 weight
0.00e+00 2.78e+04 input[0]
5.36e-05 7.92e+02 output
[...]`,highlighted:`                  *** Starting batch number=1 ***
abs min  abs max  metadata
                  shared Embedding
1.01e<span class="hljs-string">-06</span> 7.92e<span class="hljs-string">+02</span> weight
0.00e<span class="hljs-string">+00</span> 2.47e<span class="hljs-string">+04</span> input[0]
5.36e<span class="hljs-string">-05</span> 7.92e<span class="hljs-string">+02</span> output
[...]
                  decoder.dropout Dropout
1.60e<span class="hljs-string">-07</span> 2.27e<span class="hljs-string">+01</span> input[0]
0.00e<span class="hljs-string">+00</span> 2.52e<span class="hljs-string">+01</span> output
                  decoder T5Stack
     not a tensor output
                  lm_head Linear
1.01e<span class="hljs-string">-06</span> 7.92e<span class="hljs-string">+02</span> weight
0.00e<span class="hljs-string">+00</span> 1.11e<span class="hljs-string">+00</span> input[0]
6.06e<span class="hljs-string">-02</span> 8.39e<span class="hljs-string">+01</span> output
                   T5ForConditionalGeneration
     not a tensor output

                  *** Starting batch number=3 ***
abs min  abs max  metadata
                  shared Embedding
1.01e<span class="hljs-string">-06</span> 7.92e<span class="hljs-string">+02</span> weight
0.00e<span class="hljs-string">+00</span> 2.78e<span class="hljs-string">+04</span> input[0]
5.36e<span class="hljs-string">-05</span> 7.92e<span class="hljs-string">+02</span> output
[...]`}}),Pe=new P({props:{code:"debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[1, 3], abort_after_batch_num=3)",highlighted:'debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[<span class="hljs-number">1</span>, <span class="hljs-number">3</span>], abort_after_batch_num=<span class="hljs-number">3</span>)'}}),{c(){c=r("meta"),D=d(),m=r("h1"),v=r("a"),C=r("span"),f($.$$.fragment),E=d(),N=r("span"),dn=n("Debugging"),Vs=d(),S=r("h2"),B=r("a"),Je=r("span"),f(ie.$$.fragment),cn=d(),Qe=r("span"),mn=n("Debug de problemas de Network multi-GPU"),Ys=d(),H=r("p"),fn=n("Cuando entrenas o infieres con "),We=r("code"),bn=n("DistributedDataParallel"),hn=n(" y varias GPUs, si encuentras problemas de intercomunicaci\xF3n entre procesos y/o nodos, puedes usar el siguiente script para diagnosticar problemas de red."),Js=d(),f(ce.$$.fragment),Qs=d(),Oe=r("p"),jn=n("Por ejemplo, para probar c\xF3mo interact\xFAan 2 GPUs, haz lo siguiente:"),Ws=d(),f(me.$$.fragment),Xs=d(),Le=r("p"),_n=n("Si ambos procesos pueden hablar entre s\xED y asignar la memoria de la GPU, cada uno imprimir\xE1 un status OK."),Zs=d(),xe=r("p"),wn=n("Para m\xE1s GPUs o nodos, ajusta los argumentos en el script."),ea=d(),Te=r("p"),vn=n("Encontrar\xE1s muchos m\xE1s detalles dentro del script de diagn\xF3stico e incluso una receta de c\xF3mo ejecutarlo en un entorno SLURM."),sa=d(),V=r("p"),gn=n("Un nivel adicional de debug es agregar la variable de entorno "),Xe=r("code"),$n=n("NCCL_DEBUG=INFO"),yn=n(" de la siguiente manera:"),aa=d(),f(fe.$$.fragment),na=d(),Ue=r("p"),En=n("Esto mostrar\xE1 mucha informaci\xF3n de debug relacionada con NCCL, que luego puedes buscar online si encuentras que reporta alg\xFAn problema. O si no est\xE1s seguro de c\xF3mo interpretar el output, puedes compartir el archivo de log en un Issue."),la=d(),F=r("h2"),Y=r("a"),Ze=r("span"),f(be.$$.fragment),Dn=d(),es=r("span"),qn=n("Detecci\xF3n de Underflow y Overflow"),ta=d(),f(J.$$.fragment),ra=d(),f(Q.$$.fragment),oa=d(),f(W.$$.fragment),pa=d(),L=r("p"),kn=n("Si empiezas a obtener "),ss=r("code"),Pn=n("loss=NaN"),Cn=n(" o el modelo muestra alg\xFAn otro comportamiento anormal debido a "),as=r("code"),On=n("inf"),Ln=n(" o "),ns=r("code"),xn=n("nan"),Tn=n(` en
activations o weights hay que descubrir d\xF3nde se produce el primer underflow o overflow y qu\xE9 lo ha provocado. Por suerte
puedes lograrlo f\xE1cilmente activando un m\xF3dulo especial que har\xE1 la detecci\xF3n autom\xE1ticamente.`),ua=d(),X=r("p"),Un=n("Si est\xE1s usando "),ls=r("code"),zn=n("Trainer"),Gn=n(", solo necesitas a\xF1adir:"),da=d(),f(he.$$.fragment),ia=d(),A=r("p"),Nn=n("a los argumentos normales de la l\xEDnea de comandos, o pasar "),ts=r("code"),An=n('debug="underflow_overflow"'),Rn=n(" al crear el objeto "),rs=r("code"),Sn=n("TrainingArguments"),Fn=n("."),ca=d(),ze=r("p"),Mn=n("Si est\xE1s usando tu propio bucle de entrenamiento u otro Trainer puedes lograr lo mismo con:"),ma=d(),f(je.$$.fragment),fa=d(),O=r("p"),os=r("code"),In=n("DebugUnderflowOverflow"),Kn=n(` inserta hooks en el modelo que inmediatamente despu\xE9s de cada forward
testear\xE1 las variables de input y output y tambi\xE9n los weights del m\xF3dulo correspondiente. Tan pronto como se detecte `),ps=r("code"),Bn=n("inf"),Hn=n(` o
`),us=r("code"),Vn=n("nan"),Yn=n(` se detecta en al menos un elemento de las activations o weights, el programa afirmar\xE1 e imprimir\xE1 un informe
como este (esto fue capturado con `),ds=r("code"),Jn=n("google/mt5-small"),Qn=n(" bajo fp16 mixed precision):"),ba=d(),f(_e.$$.fragment),ha=d(),Ge=r("p"),Wn=n("El output del ejemplo se ha recortado en el centro por razones de brevedad."),ja=d(),g=r("p"),Xn=n(`La segunda columna muestra el valor del elemento m\xE1s grande en t\xE9rminos absolutos, por lo que si observas con detenimiento los \xFAltimos fotogramas,
los inputs y outputs estaban en el rango de `),is=r("code"),Zn=n("1e4"),el=n(`. As\xED que cuando este entrenamiento se hizo con fp16 mixed precision,
el \xFAltimo paso sufri\xF3 overflow (ya que bajo `),cs=r("code"),sl=n("fp16"),al=n(" el mayor n\xFAmero antes de "),ms=r("code"),nl=n("inf"),ll=n(" es "),fs=r("code"),tl=n("64e3"),rl=n(`). Para evitar overflows en
`),bs=r("code"),ol=n("fp16"),pl=n(" las activations deben permanecer muy por debajo de "),hs=r("code"),ul=n("1e4"),dl=n(", porque "),js=r("code"),il=n("1e4 * 1e4 = 1e8"),cl=n(` por lo que cualquier matrix multiplication con
grandes activations va a llevar a una condici\xF3n de overflow num\xE9rico.`),_a=d(),Z=r("p"),ml=n("Al principio del output puedes descubrir en qu\xE9 n\xFAmero de batch se produjo el problema (aqu\xED "),_s=r("code"),fl=n("Detected inf/nan during batch_number=0"),bl=n(" significa que el problema se produjo en el primer batch)."),wa=d(),Ne=r("p"),hl=n(`Cada frame del informe comienza declarando la entrada completamente calificada para el m\xF3dulo correspondiente que este frame est\xE1 reportando.
Si nos fijamos s\xF3lo en este frame:`),va=d(),f(we.$$.fragment),ga=d(),x=r("p"),jl=n("Aqu\xED, "),ws=r("code"),_l=n("encoder.block.2.layer.1.layer_norm"),wl=n(` indica que era una layer norm para la primera capa, del segundo
block del encoder. Y la call espec\xEDfica del `),vs=r("code"),vl=n("forward"),gl=n(" es "),gs=r("code"),$l=n("T5LayerNorm"),yl=n("."),$a=d(),Ae=r("p"),El=n("Veamos los \xFAltimos frames de ese informe:"),ya=d(),f(ve.$$.fragment),Ea=d(),q=r("p"),Dl=n("El \xFAltimo frame informa para la funci\xF3n "),$s=r("code"),ql=n("Dropout.forward"),kl=n(` con la primera entrada para el \xFAnico input y la segunda para el
\xFAnico output. Puedes ver que fue llamada desde un atributo `),ys=r("code"),Pl=n("dropout"),Cl=n(" dentro de la clase "),Es=r("code"),Ol=n("DenseReluDense"),Ll=n(`. Podemos ver
que ocurri\xF3 durante la primera capa, del segundo block, durante el primer batch. Por \xFAltimo, el mayor absoluto
elementos de input fue `),Ds=r("code"),xl=n("6.27e+04"),Tl=n(" y el mismo para el output fue "),qs=r("code"),Ul=n("inf"),zl=n("."),Da=d(),T=r("p"),Gl=n("Puedes ver aqu\xED, que "),ks=r("code"),Nl=n("T5DenseGatedGeluDense.forward"),Al=n(` result\xF3 en output activations, cuyo valor m\xE1ximo absoluto fue
alrededor de 62.7K, que est\xE1 muy cerca del l\xEDmite m\xE1ximo de fp16 de 64K. En el siguiente frame tenemos `),Ps=r("code"),Rl=n("Dropout"),Sl=n(`, el cual renormaliza
los weights, despu\xE9s de poner a cero algunos de los elementos, lo que empuja el valor m\xE1ximo absoluto a m\xE1s de 64K, y obtenemos un
overflow (`),Cs=r("code"),Fl=n("inf"),Ml=n(")."),qa=d(),Re=r("p"),Il=n("Como puedes ver son los frames anteriores los que tenemos que mirar cuando los n\xFAmeros empiezan a ser muy grandes para n\xFAmeros fp16."),ka=d(),ee=r("p"),Kl=n("Combinemos el informe con el c\xF3digo de "),Os=r("code"),Bl=n("models/t5/modeling_t5.py"),Hl=n(":"),Pa=d(),f(ge.$$.fragment),Ca=d(),se=r("p"),Vl=n("Ahora es f\xE1cil ver la call "),Ls=r("code"),Yl=n("dropout"),Jl=n(", y tambi\xE9n todas las calls anteriores."),Oa=d(),ae=r("p"),Ql=n("Dado que la detecci\xF3n se produce en un forward hook, estos informes se imprimen inmediatamente despu\xE9s de que cada "),xs=r("code"),Wl=n("forward"),Xl=n(`
responda.`),La=d(),U=r("p"),Zl=n(`Volviendo al informe completo, para actuar sobre \xE9l y arreglar el problema, tenemos que subir unos cuantos frames donde los n\xFAmeros
empezaron a subir y probablemente cambiar al modo `),Ts=r("code"),et=n("fp32"),st=n(` aqu\xED, para que los n\xFAmeros no sufran overflow cuando se multipliquen
o al sumarlos. Por supuesto, puede haber otras soluciones. Por ejemplo, podr\xEDamos desactivar `),Us=r("code"),at=n("amp"),nt=n(` temporalmente si est\xE1
activado, despu\xE9s de mover el original `),zs=r("code"),lt=n("forward"),tt=n(" dentro de un helper wrapper, as\xED:"),xa=d(),f($e.$$.fragment),Ta=d(),R=r("p"),rt=n(`Como el detector autom\xE1tico s\xF3lo informa de los inputs y outputs de los frames completos, una vez que sepas d\xF3nde buscar, puedes
analizar tambi\xE9n las etapas intermedias de una funci\xF3n espec\xEDfica de `),Gs=r("code"),ot=n("forward"),pt=n(`. En este caso, puede utilizar la funci\xF3n
funci\xF3n de ayuda `),Ns=r("code"),ut=n("detect_overflow"),dt=n(" para inyectar el detector donde quieras, por ejemplo:"),Ua=d(),f(ye.$$.fragment),za=d(),z=r("p"),it=n("Puedes ver que hemos a\xF1adido 2 de estos y ahora se trackea si "),As=r("code"),ct=n("inf"),mt=n(" o "),Rs=r("code"),ft=n("nan"),bt=n(" para "),Ss=r("code"),ht=n("forwarded_states"),jt=n(` fue detectado
en alg\xFAn punto intermedio.`),Ga=d(),ne=r("p"),_t=n("De hecho, el detector ya informa de esto porque cada una de las llamadas en el ejemplo anterior es un "),Fs=r("code"),wt=n("nn.Module"),vt=n(`, pero
digamos que si tuvieras algunos c\xE1lculos directos locales, as\xED es como lo har\xEDas.`),Na=d(),Se=r("p"),gt=n(`Adem\xE1s, si est\xE1s instanciando el debugger en tu propio c\xF3digo, puedes ajustar el n\xFAmero de frames impresos de
su valor por defecto, por ejemplo:`),Aa=d(),f(Ee.$$.fragment),Ra=d(),M=r("h3"),le=r("a"),Ms=r("span"),f(De.$$.fragment),$t=d(),Is=r("span"),yt=n("Rastreo de valores m\xEDnimos y m\xE1ximos absolutos de batches espec\xEDficos"),Sa=d(),Fe=r("p"),Et=n("La misma clase de debugging se puede utilizar para el rastreo por batches con la funci\xF3n de detecci\xF3n de underflow/overflow desactivada."),Fa=d(),te=r("p"),Dt=n("Digamos que quieres ver los valores m\xEDnimos y m\xE1ximos absolutos de todos los ingredientes de cada call "),Ks=r("code"),qt=n("forward"),kt=n(` de un determinado
batch, y s\xF3lo hacerlo para los batches 1 y 3. Entonces instancias esta clase como:`),Ma=d(),f(qe.$$.fragment),Ia=d(),Me=r("p"),Pt=n("Y ahora los batches 1 y 3 completos ser\xE1n rastreados usando el mismo formato que el detector de underflow/overflow."),Ka=d(),Ie=r("p"),Ct=n("Los batches son 0-index."),Ba=d(),Ke=r("p"),Ot=n(`Esto es muy \xFAtil si sabes que el programa empieza a comportarse mal despu\xE9s de un determinado n\xFAmero de batch, para que puedas avanzar r\xE1pidamente
hasta esa \xE1rea. Aqu\xED hay un ejemplo de output recortado para tal configuraci\xF3n:`),Ha=d(),f(ke.$$.fragment),Va=d(),Be=r("p"),Lt=n(`Aqu\xED obtendr\xE1s un gran n\xFAmero de frames mostrados - tantos como forward calls haya en tu modelo, por lo que puede o no ser lo que quieras, pero a veces puede ser m\xE1s f\xE1cil de usar para debug que un debugger normal.
Por ejemplo, si un problema comienza a ocurrir en el batch 150. Entonces puedes mostrar las trazas de los batches 149 y 150 y comparar d\xF3nde
los n\xFAmeros empezaron a divergir.`),Ya=d(),He=r("p"),xt=n("Tambi\xE9n puedes especificar el n\xFAmero de batch despu\xE9s del cual se debe detener el entrenamiento, con:"),Ja=d(),f(Pe.$$.fragment),this.h()},l(e){const t=eo('[data-svelte="svelte-1phssyn"]',document.head);c=o(t,"META",{name:!0,content:!0}),t.forEach(s),D=i(e),m=o(e,"H1",{class:!0});var Ce=u(m);v=o(Ce,"A",{id:!0,class:!0,href:!0});var Bs=u(v);C=o(Bs,"SPAN",{});var Hs=u(C);b($.$$.fragment,Hs),Hs.forEach(s),Bs.forEach(s),E=i(Ce),N=o(Ce,"SPAN",{});var Ut=u(N);dn=l(Ut,"Debugging"),Ut.forEach(s),Ce.forEach(s),Vs=i(e),S=o(e,"H2",{class:!0});var Wa=u(S);B=o(Wa,"A",{id:!0,class:!0,href:!0});var zt=u(B);Je=o(zt,"SPAN",{});var Gt=u(Je);b(ie.$$.fragment,Gt),Gt.forEach(s),zt.forEach(s),cn=i(Wa),Qe=o(Wa,"SPAN",{});var Nt=u(Qe);mn=l(Nt,"Debug de problemas de Network multi-GPU"),Nt.forEach(s),Wa.forEach(s),Ys=i(e),H=o(e,"P",{});var Xa=u(H);fn=l(Xa,"Cuando entrenas o infieres con "),We=o(Xa,"CODE",{});var At=u(We);bn=l(At,"DistributedDataParallel"),At.forEach(s),hn=l(Xa," y varias GPUs, si encuentras problemas de intercomunicaci\xF3n entre procesos y/o nodos, puedes usar el siguiente script para diagnosticar problemas de red."),Xa.forEach(s),Js=i(e),b(ce.$$.fragment,e),Qs=i(e),Oe=o(e,"P",{});var Rt=u(Oe);jn=l(Rt,"Por ejemplo, para probar c\xF3mo interact\xFAan 2 GPUs, haz lo siguiente:"),Rt.forEach(s),Ws=i(e),b(me.$$.fragment,e),Xs=i(e),Le=o(e,"P",{});var St=u(Le);_n=l(St,"Si ambos procesos pueden hablar entre s\xED y asignar la memoria de la GPU, cada uno imprimir\xE1 un status OK."),St.forEach(s),Zs=i(e),xe=o(e,"P",{});var Ft=u(xe);wn=l(Ft,"Para m\xE1s GPUs o nodos, ajusta los argumentos en el script."),Ft.forEach(s),ea=i(e),Te=o(e,"P",{});var Mt=u(Te);vn=l(Mt,"Encontrar\xE1s muchos m\xE1s detalles dentro del script de diagn\xF3stico e incluso una receta de c\xF3mo ejecutarlo en un entorno SLURM."),Mt.forEach(s),sa=i(e),V=o(e,"P",{});var Za=u(V);gn=l(Za,"Un nivel adicional de debug es agregar la variable de entorno "),Xe=o(Za,"CODE",{});var It=u(Xe);$n=l(It,"NCCL_DEBUG=INFO"),It.forEach(s),yn=l(Za," de la siguiente manera:"),Za.forEach(s),aa=i(e),b(fe.$$.fragment,e),na=i(e),Ue=o(e,"P",{});var Kt=u(Ue);En=l(Kt,"Esto mostrar\xE1 mucha informaci\xF3n de debug relacionada con NCCL, que luego puedes buscar online si encuentras que reporta alg\xFAn problema. O si no est\xE1s seguro de c\xF3mo interpretar el output, puedes compartir el archivo de log en un Issue."),Kt.forEach(s),la=i(e),F=o(e,"H2",{class:!0});var en=u(F);Y=o(en,"A",{id:!0,class:!0,href:!0});var Bt=u(Y);Ze=o(Bt,"SPAN",{});var Ht=u(Ze);b(be.$$.fragment,Ht),Ht.forEach(s),Bt.forEach(s),Dn=i(en),es=o(en,"SPAN",{});var Vt=u(es);qn=l(Vt,"Detecci\xF3n de Underflow y Overflow"),Vt.forEach(s),en.forEach(s),ta=i(e),b(J.$$.fragment,e),ra=i(e),b(Q.$$.fragment,e),oa=i(e),b(W.$$.fragment,e),pa=i(e),L=o(e,"P",{});var re=u(L);kn=l(re,"Si empiezas a obtener "),ss=o(re,"CODE",{});var Yt=u(ss);Pn=l(Yt,"loss=NaN"),Yt.forEach(s),Cn=l(re," o el modelo muestra alg\xFAn otro comportamiento anormal debido a "),as=o(re,"CODE",{});var Jt=u(as);On=l(Jt,"inf"),Jt.forEach(s),Ln=l(re," o "),ns=o(re,"CODE",{});var Qt=u(ns);xn=l(Qt,"nan"),Qt.forEach(s),Tn=l(re,` en
activations o weights hay que descubrir d\xF3nde se produce el primer underflow o overflow y qu\xE9 lo ha provocado. Por suerte
puedes lograrlo f\xE1cilmente activando un m\xF3dulo especial que har\xE1 la detecci\xF3n autom\xE1ticamente.`),re.forEach(s),ua=i(e),X=o(e,"P",{});var sn=u(X);Un=l(sn,"Si est\xE1s usando "),ls=o(sn,"CODE",{});var Wt=u(ls);zn=l(Wt,"Trainer"),Wt.forEach(s),Gn=l(sn,", solo necesitas a\xF1adir:"),sn.forEach(s),da=i(e),b(he.$$.fragment,e),ia=i(e),A=o(e,"P",{});var Ve=u(A);Nn=l(Ve,"a los argumentos normales de la l\xEDnea de comandos, o pasar "),ts=o(Ve,"CODE",{});var Xt=u(ts);An=l(Xt,'debug="underflow_overflow"'),Xt.forEach(s),Rn=l(Ve," al crear el objeto "),rs=o(Ve,"CODE",{});var Zt=u(rs);Sn=l(Zt,"TrainingArguments"),Zt.forEach(s),Fn=l(Ve,"."),Ve.forEach(s),ca=i(e),ze=o(e,"P",{});var er=u(ze);Mn=l(er,"Si est\xE1s usando tu propio bucle de entrenamiento u otro Trainer puedes lograr lo mismo con:"),er.forEach(s),ma=i(e),b(je.$$.fragment,e),fa=i(e),O=o(e,"P",{});var I=u(O);os=o(I,"CODE",{});var sr=u(os);In=l(sr,"DebugUnderflowOverflow"),sr.forEach(s),Kn=l(I,` inserta hooks en el modelo que inmediatamente despu\xE9s de cada forward
testear\xE1 las variables de input y output y tambi\xE9n los weights del m\xF3dulo correspondiente. Tan pronto como se detecte `),ps=o(I,"CODE",{});var ar=u(ps);Bn=l(ar,"inf"),ar.forEach(s),Hn=l(I,` o
`),us=o(I,"CODE",{});var nr=u(us);Vn=l(nr,"nan"),nr.forEach(s),Yn=l(I,` se detecta en al menos un elemento de las activations o weights, el programa afirmar\xE1 e imprimir\xE1 un informe
como este (esto fue capturado con `),ds=o(I,"CODE",{});var lr=u(ds);Jn=l(lr,"google/mt5-small"),lr.forEach(s),Qn=l(I," bajo fp16 mixed precision):"),I.forEach(s),ba=i(e),b(_e.$$.fragment,e),ha=i(e),Ge=o(e,"P",{});var tr=u(Ge);Wn=l(tr,"El output del ejemplo se ha recortado en el centro por razones de brevedad."),tr.forEach(s),ja=i(e),g=o(e,"P",{});var k=u(g);Xn=l(k,`La segunda columna muestra el valor del elemento m\xE1s grande en t\xE9rminos absolutos, por lo que si observas con detenimiento los \xFAltimos fotogramas,
los inputs y outputs estaban en el rango de `),is=o(k,"CODE",{});var rr=u(is);Zn=l(rr,"1e4"),rr.forEach(s),el=l(k,`. As\xED que cuando este entrenamiento se hizo con fp16 mixed precision,
el \xFAltimo paso sufri\xF3 overflow (ya que bajo `),cs=o(k,"CODE",{});var or=u(cs);sl=l(or,"fp16"),or.forEach(s),al=l(k," el mayor n\xFAmero antes de "),ms=o(k,"CODE",{});var pr=u(ms);nl=l(pr,"inf"),pr.forEach(s),ll=l(k," es "),fs=o(k,"CODE",{});var ur=u(fs);tl=l(ur,"64e3"),ur.forEach(s),rl=l(k,`). Para evitar overflows en
`),bs=o(k,"CODE",{});var dr=u(bs);ol=l(dr,"fp16"),dr.forEach(s),pl=l(k," las activations deben permanecer muy por debajo de "),hs=o(k,"CODE",{});var ir=u(hs);ul=l(ir,"1e4"),ir.forEach(s),dl=l(k,", porque "),js=o(k,"CODE",{});var cr=u(js);il=l(cr,"1e4 * 1e4 = 1e8"),cr.forEach(s),cl=l(k,` por lo que cualquier matrix multiplication con
grandes activations va a llevar a una condici\xF3n de overflow num\xE9rico.`),k.forEach(s),_a=i(e),Z=o(e,"P",{});var an=u(Z);ml=l(an,"Al principio del output puedes descubrir en qu\xE9 n\xFAmero de batch se produjo el problema (aqu\xED "),_s=o(an,"CODE",{});var mr=u(_s);fl=l(mr,"Detected inf/nan during batch_number=0"),mr.forEach(s),bl=l(an," significa que el problema se produjo en el primer batch)."),an.forEach(s),wa=i(e),Ne=o(e,"P",{});var fr=u(Ne);hl=l(fr,`Cada frame del informe comienza declarando la entrada completamente calificada para el m\xF3dulo correspondiente que este frame est\xE1 reportando.
Si nos fijamos s\xF3lo en este frame:`),fr.forEach(s),va=i(e),b(we.$$.fragment,e),ga=i(e),x=o(e,"P",{});var oe=u(x);jl=l(oe,"Aqu\xED, "),ws=o(oe,"CODE",{});var br=u(ws);_l=l(br,"encoder.block.2.layer.1.layer_norm"),br.forEach(s),wl=l(oe,` indica que era una layer norm para la primera capa, del segundo
block del encoder. Y la call espec\xEDfica del `),vs=o(oe,"CODE",{});var hr=u(vs);vl=l(hr,"forward"),hr.forEach(s),gl=l(oe," es "),gs=o(oe,"CODE",{});var jr=u(gs);$l=l(jr,"T5LayerNorm"),jr.forEach(s),yl=l(oe,"."),oe.forEach(s),$a=i(e),Ae=o(e,"P",{});var _r=u(Ae);El=l(_r,"Veamos los \xFAltimos frames de ese informe:"),_r.forEach(s),ya=i(e),b(ve.$$.fragment,e),Ea=i(e),q=o(e,"P",{});var G=u(q);Dl=l(G,"El \xFAltimo frame informa para la funci\xF3n "),$s=o(G,"CODE",{});var wr=u($s);ql=l(wr,"Dropout.forward"),wr.forEach(s),kl=l(G,` con la primera entrada para el \xFAnico input y la segunda para el
\xFAnico output. Puedes ver que fue llamada desde un atributo `),ys=o(G,"CODE",{});var vr=u(ys);Pl=l(vr,"dropout"),vr.forEach(s),Cl=l(G," dentro de la clase "),Es=o(G,"CODE",{});var gr=u(Es);Ol=l(gr,"DenseReluDense"),gr.forEach(s),Ll=l(G,`. Podemos ver
que ocurri\xF3 durante la primera capa, del segundo block, durante el primer batch. Por \xFAltimo, el mayor absoluto
elementos de input fue `),Ds=o(G,"CODE",{});var $r=u(Ds);xl=l($r,"6.27e+04"),$r.forEach(s),Tl=l(G," y el mismo para el output fue "),qs=o(G,"CODE",{});var yr=u(qs);Ul=l(yr,"inf"),yr.forEach(s),zl=l(G,"."),G.forEach(s),Da=i(e),T=o(e,"P",{});var pe=u(T);Gl=l(pe,"Puedes ver aqu\xED, que "),ks=o(pe,"CODE",{});var Er=u(ks);Nl=l(Er,"T5DenseGatedGeluDense.forward"),Er.forEach(s),Al=l(pe,` result\xF3 en output activations, cuyo valor m\xE1ximo absoluto fue
alrededor de 62.7K, que est\xE1 muy cerca del l\xEDmite m\xE1ximo de fp16 de 64K. En el siguiente frame tenemos `),Ps=o(pe,"CODE",{});var Dr=u(Ps);Rl=l(Dr,"Dropout"),Dr.forEach(s),Sl=l(pe,`, el cual renormaliza
los weights, despu\xE9s de poner a cero algunos de los elementos, lo que empuja el valor m\xE1ximo absoluto a m\xE1s de 64K, y obtenemos un
overflow (`),Cs=o(pe,"CODE",{});var qr=u(Cs);Fl=l(qr,"inf"),qr.forEach(s),Ml=l(pe,")."),pe.forEach(s),qa=i(e),Re=o(e,"P",{});var kr=u(Re);Il=l(kr,"Como puedes ver son los frames anteriores los que tenemos que mirar cuando los n\xFAmeros empiezan a ser muy grandes para n\xFAmeros fp16."),kr.forEach(s),ka=i(e),ee=o(e,"P",{});var nn=u(ee);Kl=l(nn,"Combinemos el informe con el c\xF3digo de "),Os=o(nn,"CODE",{});var Pr=u(Os);Bl=l(Pr,"models/t5/modeling_t5.py"),Pr.forEach(s),Hl=l(nn,":"),nn.forEach(s),Pa=i(e),b(ge.$$.fragment,e),Ca=i(e),se=o(e,"P",{});var ln=u(se);Vl=l(ln,"Ahora es f\xE1cil ver la call "),Ls=o(ln,"CODE",{});var Cr=u(Ls);Yl=l(Cr,"dropout"),Cr.forEach(s),Jl=l(ln,", y tambi\xE9n todas las calls anteriores."),ln.forEach(s),Oa=i(e),ae=o(e,"P",{});var tn=u(ae);Ql=l(tn,"Dado que la detecci\xF3n se produce en un forward hook, estos informes se imprimen inmediatamente despu\xE9s de que cada "),xs=o(tn,"CODE",{});var Or=u(xs);Wl=l(Or,"forward"),Or.forEach(s),Xl=l(tn,`
responda.`),tn.forEach(s),La=i(e),U=o(e,"P",{});var ue=u(U);Zl=l(ue,`Volviendo al informe completo, para actuar sobre \xE9l y arreglar el problema, tenemos que subir unos cuantos frames donde los n\xFAmeros
empezaron a subir y probablemente cambiar al modo `),Ts=o(ue,"CODE",{});var Lr=u(Ts);et=l(Lr,"fp32"),Lr.forEach(s),st=l(ue,` aqu\xED, para que los n\xFAmeros no sufran overflow cuando se multipliquen
o al sumarlos. Por supuesto, puede haber otras soluciones. Por ejemplo, podr\xEDamos desactivar `),Us=o(ue,"CODE",{});var xr=u(Us);at=l(xr,"amp"),xr.forEach(s),nt=l(ue,` temporalmente si est\xE1
activado, despu\xE9s de mover el original `),zs=o(ue,"CODE",{});var Tr=u(zs);lt=l(Tr,"forward"),Tr.forEach(s),tt=l(ue," dentro de un helper wrapper, as\xED:"),ue.forEach(s),xa=i(e),b($e.$$.fragment,e),Ta=i(e),R=o(e,"P",{});var Ye=u(R);rt=l(Ye,`Como el detector autom\xE1tico s\xF3lo informa de los inputs y outputs de los frames completos, una vez que sepas d\xF3nde buscar, puedes
analizar tambi\xE9n las etapas intermedias de una funci\xF3n espec\xEDfica de `),Gs=o(Ye,"CODE",{});var Ur=u(Gs);ot=l(Ur,"forward"),Ur.forEach(s),pt=l(Ye,`. En este caso, puede utilizar la funci\xF3n
funci\xF3n de ayuda `),Ns=o(Ye,"CODE",{});var zr=u(Ns);ut=l(zr,"detect_overflow"),zr.forEach(s),dt=l(Ye," para inyectar el detector donde quieras, por ejemplo:"),Ye.forEach(s),Ua=i(e),b(ye.$$.fragment,e),za=i(e),z=o(e,"P",{});var de=u(z);it=l(de,"Puedes ver que hemos a\xF1adido 2 de estos y ahora se trackea si "),As=o(de,"CODE",{});var Gr=u(As);ct=l(Gr,"inf"),Gr.forEach(s),mt=l(de," o "),Rs=o(de,"CODE",{});var Nr=u(Rs);ft=l(Nr,"nan"),Nr.forEach(s),bt=l(de," para "),Ss=o(de,"CODE",{});var Ar=u(Ss);ht=l(Ar,"forwarded_states"),Ar.forEach(s),jt=l(de,` fue detectado
en alg\xFAn punto intermedio.`),de.forEach(s),Ga=i(e),ne=o(e,"P",{});var rn=u(ne);_t=l(rn,"De hecho, el detector ya informa de esto porque cada una de las llamadas en el ejemplo anterior es un "),Fs=o(rn,"CODE",{});var Rr=u(Fs);wt=l(Rr,"nn.Module"),Rr.forEach(s),vt=l(rn,`, pero
digamos que si tuvieras algunos c\xE1lculos directos locales, as\xED es como lo har\xEDas.`),rn.forEach(s),Na=i(e),Se=o(e,"P",{});var Sr=u(Se);gt=l(Sr,`Adem\xE1s, si est\xE1s instanciando el debugger en tu propio c\xF3digo, puedes ajustar el n\xFAmero de frames impresos de
su valor por defecto, por ejemplo:`),Sr.forEach(s),Aa=i(e),b(Ee.$$.fragment,e),Ra=i(e),M=o(e,"H3",{class:!0});var on=u(M);le=o(on,"A",{id:!0,class:!0,href:!0});var Fr=u(le);Ms=o(Fr,"SPAN",{});var Mr=u(Ms);b(De.$$.fragment,Mr),Mr.forEach(s),Fr.forEach(s),$t=i(on),Is=o(on,"SPAN",{});var Ir=u(Is);yt=l(Ir,"Rastreo de valores m\xEDnimos y m\xE1ximos absolutos de batches espec\xEDficos"),Ir.forEach(s),on.forEach(s),Sa=i(e),Fe=o(e,"P",{});var Kr=u(Fe);Et=l(Kr,"La misma clase de debugging se puede utilizar para el rastreo por batches con la funci\xF3n de detecci\xF3n de underflow/overflow desactivada."),Kr.forEach(s),Fa=i(e),te=o(e,"P",{});var pn=u(te);Dt=l(pn,"Digamos que quieres ver los valores m\xEDnimos y m\xE1ximos absolutos de todos los ingredientes de cada call "),Ks=o(pn,"CODE",{});var Br=u(Ks);qt=l(Br,"forward"),Br.forEach(s),kt=l(pn,` de un determinado
batch, y s\xF3lo hacerlo para los batches 1 y 3. Entonces instancias esta clase como:`),pn.forEach(s),Ma=i(e),b(qe.$$.fragment,e),Ia=i(e),Me=o(e,"P",{});var Hr=u(Me);Pt=l(Hr,"Y ahora los batches 1 y 3 completos ser\xE1n rastreados usando el mismo formato que el detector de underflow/overflow."),Hr.forEach(s),Ka=i(e),Ie=o(e,"P",{});var Vr=u(Ie);Ct=l(Vr,"Los batches son 0-index."),Vr.forEach(s),Ba=i(e),Ke=o(e,"P",{});var Yr=u(Ke);Ot=l(Yr,`Esto es muy \xFAtil si sabes que el programa empieza a comportarse mal despu\xE9s de un determinado n\xFAmero de batch, para que puedas avanzar r\xE1pidamente
hasta esa \xE1rea. Aqu\xED hay un ejemplo de output recortado para tal configuraci\xF3n:`),Yr.forEach(s),Ha=i(e),b(ke.$$.fragment,e),Va=i(e),Be=o(e,"P",{});var Jr=u(Be);Lt=l(Jr,`Aqu\xED obtendr\xE1s un gran n\xFAmero de frames mostrados - tantos como forward calls haya en tu modelo, por lo que puede o no ser lo que quieras, pero a veces puede ser m\xE1s f\xE1cil de usar para debug que un debugger normal.
Por ejemplo, si un problema comienza a ocurrir en el batch 150. Entonces puedes mostrar las trazas de los batches 149 y 150 y comparar d\xF3nde
los n\xFAmeros empezaron a divergir.`),Jr.forEach(s),Ya=i(e),He=o(e,"P",{});var Qr=u(He);xt=l(Qr,"Tambi\xE9n puedes especificar el n\xFAmero de batch despu\xE9s del cual se debe detener el entrenamiento, con:"),Qr.forEach(s),Ja=i(e),b(Pe.$$.fragment,e),this.h()},h(){y(c,"name","hf:doc:metadata"),y(c,"content",JSON.stringify(ro)),y(v,"id","debugging"),y(v,"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"),y(v,"href","#debugging"),y(m,"class","relative group"),y(B,"id","debug-de-problemas-de-network-multigpu"),y(B,"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"),y(B,"href","#debug-de-problemas-de-network-multigpu"),y(S,"class","relative group"),y(Y,"id","deteccin-de-underflow-y-overflow"),y(Y,"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"),y(Y,"href","#deteccin-de-underflow-y-overflow"),y(F,"class","relative group"),y(le,"id","rastreo-de-valores-mnimos-y-mximos-absolutos-de-batches-especficos"),y(le,"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"),y(le,"href","#rastreo-de-valores-mnimos-y-mximos-absolutos-de-batches-especficos"),y(M,"class","relative group")},m(e,t){a(document.head,c),p(e,D,t),p(e,m,t),a(m,v),a(v,C),h($,C,null),a(m,E),a(m,N),a(N,dn),p(e,Vs,t),p(e,S,t),a(S,B),a(B,Je),h(ie,Je,null),a(S,cn),a(S,Qe),a(Qe,mn),p(e,Ys,t),p(e,H,t),a(H,fn),a(H,We),a(We,bn),a(H,hn),p(e,Js,t),h(ce,e,t),p(e,Qs,t),p(e,Oe,t),a(Oe,jn),p(e,Ws,t),h(me,e,t),p(e,Xs,t),p(e,Le,t),a(Le,_n),p(e,Zs,t),p(e,xe,t),a(xe,wn),p(e,ea,t),p(e,Te,t),a(Te,vn),p(e,sa,t),p(e,V,t),a(V,gn),a(V,Xe),a(Xe,$n),a(V,yn),p(e,aa,t),h(fe,e,t),p(e,na,t),p(e,Ue,t),a(Ue,En),p(e,la,t),p(e,F,t),a(F,Y),a(Y,Ze),h(be,Ze,null),a(F,Dn),a(F,es),a(es,qn),p(e,ta,t),h(J,e,t),p(e,ra,t),h(Q,e,t),p(e,oa,t),h(W,e,t),p(e,pa,t),p(e,L,t),a(L,kn),a(L,ss),a(ss,Pn),a(L,Cn),a(L,as),a(as,On),a(L,Ln),a(L,ns),a(ns,xn),a(L,Tn),p(e,ua,t),p(e,X,t),a(X,Un),a(X,ls),a(ls,zn),a(X,Gn),p(e,da,t),h(he,e,t),p(e,ia,t),p(e,A,t),a(A,Nn),a(A,ts),a(ts,An),a(A,Rn),a(A,rs),a(rs,Sn),a(A,Fn),p(e,ca,t),p(e,ze,t),a(ze,Mn),p(e,ma,t),h(je,e,t),p(e,fa,t),p(e,O,t),a(O,os),a(os,In),a(O,Kn),a(O,ps),a(ps,Bn),a(O,Hn),a(O,us),a(us,Vn),a(O,Yn),a(O,ds),a(ds,Jn),a(O,Qn),p(e,ba,t),h(_e,e,t),p(e,ha,t),p(e,Ge,t),a(Ge,Wn),p(e,ja,t),p(e,g,t),a(g,Xn),a(g,is),a(is,Zn),a(g,el),a(g,cs),a(cs,sl),a(g,al),a(g,ms),a(ms,nl),a(g,ll),a(g,fs),a(fs,tl),a(g,rl),a(g,bs),a(bs,ol),a(g,pl),a(g,hs),a(hs,ul),a(g,dl),a(g,js),a(js,il),a(g,cl),p(e,_a,t),p(e,Z,t),a(Z,ml),a(Z,_s),a(_s,fl),a(Z,bl),p(e,wa,t),p(e,Ne,t),a(Ne,hl),p(e,va,t),h(we,e,t),p(e,ga,t),p(e,x,t),a(x,jl),a(x,ws),a(ws,_l),a(x,wl),a(x,vs),a(vs,vl),a(x,gl),a(x,gs),a(gs,$l),a(x,yl),p(e,$a,t),p(e,Ae,t),a(Ae,El),p(e,ya,t),h(ve,e,t),p(e,Ea,t),p(e,q,t),a(q,Dl),a(q,$s),a($s,ql),a(q,kl),a(q,ys),a(ys,Pl),a(q,Cl),a(q,Es),a(Es,Ol),a(q,Ll),a(q,Ds),a(Ds,xl),a(q,Tl),a(q,qs),a(qs,Ul),a(q,zl),p(e,Da,t),p(e,T,t),a(T,Gl),a(T,ks),a(ks,Nl),a(T,Al),a(T,Ps),a(Ps,Rl),a(T,Sl),a(T,Cs),a(Cs,Fl),a(T,Ml),p(e,qa,t),p(e,Re,t),a(Re,Il),p(e,ka,t),p(e,ee,t),a(ee,Kl),a(ee,Os),a(Os,Bl),a(ee,Hl),p(e,Pa,t),h(ge,e,t),p(e,Ca,t),p(e,se,t),a(se,Vl),a(se,Ls),a(Ls,Yl),a(se,Jl),p(e,Oa,t),p(e,ae,t),a(ae,Ql),a(ae,xs),a(xs,Wl),a(ae,Xl),p(e,La,t),p(e,U,t),a(U,Zl),a(U,Ts),a(Ts,et),a(U,st),a(U,Us),a(Us,at),a(U,nt),a(U,zs),a(zs,lt),a(U,tt),p(e,xa,t),h($e,e,t),p(e,Ta,t),p(e,R,t),a(R,rt),a(R,Gs),a(Gs,ot),a(R,pt),a(R,Ns),a(Ns,ut),a(R,dt),p(e,Ua,t),h(ye,e,t),p(e,za,t),p(e,z,t),a(z,it),a(z,As),a(As,ct),a(z,mt),a(z,Rs),a(Rs,ft),a(z,bt),a(z,Ss),a(Ss,ht),a(z,jt),p(e,Ga,t),p(e,ne,t),a(ne,_t),a(ne,Fs),a(Fs,wt),a(ne,vt),p(e,Na,t),p(e,Se,t),a(Se,gt),p(e,Aa,t),h(Ee,e,t),p(e,Ra,t),p(e,M,t),a(M,le),a(le,Ms),h(De,Ms,null),a(M,$t),a(M,Is),a(Is,yt),p(e,Sa,t),p(e,Fe,t),a(Fe,Et),p(e,Fa,t),p(e,te,t),a(te,Dt),a(te,Ks),a(Ks,qt),a(te,kt),p(e,Ma,t),h(qe,e,t),p(e,Ia,t),p(e,Me,t),a(Me,Pt),p(e,Ka,t),p(e,Ie,t),a(Ie,Ct),p(e,Ba,t),p(e,Ke,t),a(Ke,Ot),p(e,Ha,t),h(ke,e,t),p(e,Va,t),p(e,Be,t),a(Be,Lt),p(e,Ya,t),p(e,He,t),a(He,xt),p(e,Ja,t),h(Pe,e,t),Qa=!0},p(e,[t]){const Ce={};t&2&&(Ce.$$scope={dirty:t,ctx:e}),J.$set(Ce);const Bs={};t&2&&(Bs.$$scope={dirty:t,ctx:e}),Q.$set(Bs);const Hs={};t&2&&(Hs.$$scope={dirty:t,ctx:e}),W.$set(Hs)},i(e){Qa||(j($.$$.fragment,e),j(ie.$$.fragment,e),j(ce.$$.fragment,e),j(me.$$.fragment,e),j(fe.$$.fragment,e),j(be.$$.fragment,e),j(J.$$.fragment,e),j(Q.$$.fragment,e),j(W.$$.fragment,e),j(he.$$.fragment,e),j(je.$$.fragment,e),j(_e.$$.fragment,e),j(we.$$.fragment,e),j(ve.$$.fragment,e),j(ge.$$.fragment,e),j($e.$$.fragment,e),j(ye.$$.fragment,e),j(Ee.$$.fragment,e),j(De.$$.fragment,e),j(qe.$$.fragment,e),j(ke.$$.fragment,e),j(Pe.$$.fragment,e),Qa=!0)},o(e){_($.$$.fragment,e),_(ie.$$.fragment,e),_(ce.$$.fragment,e),_(me.$$.fragment,e),_(fe.$$.fragment,e),_(be.$$.fragment,e),_(J.$$.fragment,e),_(Q.$$.fragment,e),_(W.$$.fragment,e),_(he.$$.fragment,e),_(je.$$.fragment,e),_(_e.$$.fragment,e),_(we.$$.fragment,e),_(ve.$$.fragment,e),_(ge.$$.fragment,e),_($e.$$.fragment,e),_(ye.$$.fragment,e),_(Ee.$$.fragment,e),_(De.$$.fragment,e),_(qe.$$.fragment,e),_(ke.$$.fragment,e),_(Pe.$$.fragment,e),Qa=!1},d(e){s(c),e&&s(D),e&&s(m),w($),e&&s(Vs),e&&s(S),w(ie),e&&s(Ys),e&&s(H),e&&s(Js),w(ce,e),e&&s(Qs),e&&s(Oe),e&&s(Ws),w(me,e),e&&s(Xs),e&&s(Le),e&&s(Zs),e&&s(xe),e&&s(ea),e&&s(Te),e&&s(sa),e&&s(V),e&&s(aa),w(fe,e),e&&s(na),e&&s(Ue),e&&s(la),e&&s(F),w(be),e&&s(ta),w(J,e),e&&s(ra),w(Q,e),e&&s(oa),w(W,e),e&&s(pa),e&&s(L),e&&s(ua),e&&s(X),e&&s(da),w(he,e),e&&s(ia),e&&s(A),e&&s(ca),e&&s(ze),e&&s(ma),w(je,e),e&&s(fa),e&&s(O),e&&s(ba),w(_e,e),e&&s(ha),e&&s(Ge),e&&s(ja),e&&s(g),e&&s(_a),e&&s(Z),e&&s(wa),e&&s(Ne),e&&s(va),w(we,e),e&&s(ga),e&&s(x),e&&s($a),e&&s(Ae),e&&s(ya),w(ve,e),e&&s(Ea),e&&s(q),e&&s(Da),e&&s(T),e&&s(qa),e&&s(Re),e&&s(ka),e&&s(ee),e&&s(Pa),w(ge,e),e&&s(Ca),e&&s(se),e&&s(Oa),e&&s(ae),e&&s(La),e&&s(U),e&&s(xa),w($e,e),e&&s(Ta),e&&s(R),e&&s(Ua),w(ye,e),e&&s(za),e&&s(z),e&&s(Ga),e&&s(ne),e&&s(Na),e&&s(Se),e&&s(Aa),w(Ee,e),e&&s(Ra),e&&s(M),w(De),e&&s(Sa),e&&s(Fe),e&&s(Fa),e&&s(te),e&&s(Ma),w(qe,e),e&&s(Ia),e&&s(Me),e&&s(Ka),e&&s(Ie),e&&s(Ba),e&&s(Ke),e&&s(Ha),w(ke,e),e&&s(Va),e&&s(Be),e&&s(Ya),e&&s(He),e&&s(Ja),w(Pe,e)}}}const ro={local:"debugging",sections:[{local:"debug-de-problemas-de-network-multigpu",title:"Debug de problemas de Network multi-GPU"},{local:"deteccin-de-underflow-y-overflow",sections:[{local:"rastreo-de-valores-mnimos-y-mximos-absolutos-de-batches-especficos",title:"Rastreo de valores m\xEDnimos y m\xE1ximos absolutos de batches espec\xEDficos"}],title:"Detecci\xF3n de Underflow y Overflow"}],title:"Debugging"};function oo(K){return so(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class mo extends Wr{constructor(c){super();Xr(this,c,oo,to,Zr,{})}}export{mo as default,ro as metadata};
