Nj*SSKrSSKJr SSKrSSKJr SSKJrJrJ r J r SSK J r SSjr SrSSjrS r\R"S \S 4S j5r\R"S \S 4S j5r\R"S \S 4Sj5rg)N) Generator)global_decomposition_table) _rnn_helper gather_paramsgru_cell lstm_cell) while_loopc(^^^^USnUSmU(aUSOSnU(aUSOSm[U5S:XaUSO[U5S:XaUSOSmUSRS5nUSRS5n[RRR XU5mU(aTR S5OTm[R"TRS5/[URSS5Q7URURS.6n U4S jn UUUU4S jn [R"S[RS 9n [XXXx/5upnnU(aUR S5nXR!S5UR!S544$) aQ 1 layer fn for while loop LSTM Args: inp: Input tensor of shape (seq_len, batch, input_size) hidden: Tuple of (hx, cx) hidden states params: List of weight and bias tensors has_biases: Whether biases are included reverse: Whether to process sequence in reverse Returns: Tuple of (output, (final_hx, final_cx)) rNdtypedevicec,>UTRS5:$Nrsize)iouthxcxprecomputed_inputs f/root/GenerationalWealth/GenerationalWealth/venv/lib/python3.13/site-packages/torch/export/_patches.pycond_fn*one_layer_while_loop_lstm..cond_fn.$))!,,,c >UR5n[R"U5 [R"UTRS5S- S9 [ TUX#TTTSS9up#UR 5nUR S5X'US-XU4$)Nrr maxr ) chunk_dim)itemtorch_check_is_sizerrclonesqueeze) idxrrrrhh_bias hh_weight hr_weightrs rbody_fn*one_layer_while_loop_lstm..body_fn1s HHJ Q Q$5$:$:1$=$AB a ")WiST iikAQw##r r)len unsqueezer&nn functionallinearflipemptyrtupleshaperrtensorint64r r))inphiddenparams has_biasesreverse ih_weightih_biasrr step_outputrr.cnt_rfinal_hxfinal_cxr+r,r-rs @@@@rone_layer_while_loop_lstmrH s{q Iq I%fQi4G%fQi4G[A%q F q8H6!9d   Q B   Q B++2237K5<)..q1BS++q! rxx| hhyy K- $ $ ,,q ,C!+3R4"AHhhhqk !!!$h&6&6q&9: ::r c [U5S:wa [S5e[X#USRS5USRS5:g5n[ [ USUS55n [ n [UU UUUUUUUU 5 up[ [ U 65n U [R"U SS5[R"U SS54$)aj LSTM implementation using while_loop for export compatibility. This is a drop-in replacement for the default LSTM decomposition that uses while_loop instead of Python loops, making it more suitable for torch.export. Args: input: Input tensor hx: Tuple of (h0, c0) hidden states params: List of weight and bias tensors has_biases: Whether biases are included num_layers: Number of LSTM layers dropout: Dropout probability train: Training mode bidirectional: Whether to use bidirectional LSTM batch_first: Whether batch dimension is first Returns: Tuple of (output, h_n, c_n) r zlstm expects two hidden statesrr ) r1AssertionErrorrrlistziprHrr&stack inputrr>r? num_layersdropouttrain bidirectional batch_firstr=layer_fnr final_hiddenss rlstm_while_loop_implrWIs> 2w!|=>> 6r!uzz!}1 1 /M NF #beRU# $F(H$   Cm,-M  M!,a0%++mA>NPQ2R RRr c^ ^^^^USmUSmU(aUSOSmU(aUSOSm [RRRUTT5mU(aTR S5OTmUR S5n[R "TRS5/[URSS5Q7URURS.6nU4SjnU UUUU4Sjn[R"S[RS 9n [XxXU/5upn U(aU R S5n XRS54$) a< 1 layer fn for while loop GRU Args: inp: Input tensor of shape (seq_len, batch, input_size) hidden: Hidden state tensor params: List of weight and bias tensors has_biases: Whether biases are included reverse: Whether to process sequence in reverse Returns: Tuple of (output, final_hidden) rr r Nr rc,>UTRS5:$rr)rr cur_hiddenrs rr)one_layer_while_loop_gru..cond_fnrr c>UR5n[R"U5 [R"UTRS5S- S9 [ TUUTTTT5nUR 5nUR S5X'US-X4$)Nrr r")r%r&r'rrr(r)) r*rrZrr+r,rBrArs rr.)one_layer_while_loop_gru..body_fns HHJ Q Q$5$:$:1$=$AB a *i)W iik##A&Qw''r r0)r&r3r4r5r6r2r7rr8r9rrr:r;r r))r<r=r>r?r@rZrCrr.rDrEr final_hiddenr+r,rBrArs @@@@@rone_layer_while_loop_grur_}s'q Iq I%fQi4G%fQi4G++223 7K5<)..q1BS!!!$J++q! z# $  K- ( ( ,,q ,C%g:8VWALhhqk $$Q' ''r c [X#S5n[URS55n [n [ UU UUUUUUUU 5 upU [ R "U S54$)aU GRU implementation using while_loop for export compatibility. This is a drop-in replacement for the default GRU decomposition that uses while_loop instead of Python loops, making it more suitable for torch.export. Args: input: Input tensor hx: Hidden state tensor params: List of weight and bias tensors has_biases: Whether biases are included num_layers: Number of GRU layers dropout: Dropout probability train: Training mode bidirectional: Whether to use bidirectional GRU batch_first: Whether batch dimension is first Returns: Tuple of (output, h_n) Fr)rrKunbindr_rr&rMrNs rgru_while_loop_implrbsj>6u 5F "))A, F'H$   C  M1- --r return)NNNc#n# [SnURUS5nURR[RR R S5nXU'XR[RR R 'Sv UbX2U'OURUS5 Ub2UUR[RR R 'gURR[RR R S5 g!UbX2U'OURUS5 Ub2UUR[RR R 'fURR[RR R S5 f=f7f)af Generic context manager for registering while_loop-based RNN decompositions. Args: rnn_op: The aten operation to patch (e.g., torch.ops.aten.lstm.input) rnn_impl: The while_loop-based implementation function Note: This is an internal helper. Use register_lstm_while_loop_decomposition() or register_gru_while_loop_decomposition() instead. post_autogradN)rget py_kernelsr&_C DispatchKeyCompositeImplicitAutogradpop)rnn_oprnn_implregistryoriginal_decomporiginal_py_kernels r&_register_rnn_while_loop_decompositionrqsi*/:Hll640O **.. 66X#LT%((..HHI   &.V  LL &  )"   ehh22LL M    ! !%(("6"6"P"PRV W  &.V  LL &  )"   ehh22LL M    ! !%(("6"6"P"PRV Ws AF58D#BF5#BF22F5c## [[RRRR [ 5 Sv SSS5 g!,(df  g=f7f)aN Context manager that temporarily registers the while_loop-based LSTM decomposition. The while_loop-based decomposition is more suitable for export and graph-based execution, as it avoids Python control flow that cannot be captured in the graph. This should support dynamic sequence lengths, however as while_loop does not support Autograd yet, an ExportedProgram created with this will not be trainable. Usage:: from torch.export._patches import register_lstm_while_loop_decomposition from torch.export import export with register_lstm_while_loop_decomposition(): # Export your model with LSTM ep = export(model, (x, h0, c0)) Note: This context manager temporarily modifies the global decomposition table and py_kernels registration. The original registrations are restored when exiting the context. N)rqr&opsatenlstmrOrWr r®ister_lstm_while_loop_decompositionrws=0 0 !!#7     =AA  A AAc## [[RRRR [ 5 Sv SSS5 g!,(df  g=f7f)aF Context manager that temporarily registers the while_loop-based GRU decomposition. The while_loop-based decomposition is more suitable for export and graph-based execution, as it avoids Python control flow that cannot be captured in the graph. This should support dynamic sequence lengths, however as while_loop does not support Autograd yet, an ExportedProgram created with this will not be trainable. Usage:: from torch.export._patches import register_gru_while_loop_decomposition from torch.export import export with register_gru_while_loop_decomposition(): # Export your model with GRU ep = export(model, (x, h0)) Note: This context manager temporarily modifies the global decomposition table and py_kernels registration. The original registrations are restored when exiting the context. N)rqr&rsrtgrurOrbrvr r%register_gru_while_loop_decompositionr{2s=0 0   "5     rx)F) contextlibcollections.abcrr& torch._decomprtorch._decomp.decompositionsrrrr"torch._higher_order_ops.while_loopr rHrWr_rbcontextmanagerrqrwr{rvr rrs% 4XX9<;~1Sh3(l..b ,X ,X,X^  :J0K: y9I/Jr