+ j,^RIt^RIHt^RIt^RIHt^RIHtHtH t H t ^RI H t Rt RRltRtRR ltR t]P$R R l4t]P$R Rl4t]P$RRl4tR#)N Generator)global_decomposition_table) _rnn_helper gather_paramsgru_cell lstm_cell) while_loopc,a.p.pVFoSeQ\;QJdV3RlV4F 'gK RM RM!V3RlV44'dSP4oVPS4SfKnVPS4K \V4#)Nc3d<"TF%p\PPSV4xK' R#5i)N)torch_C _overlaps).0 seen_tensortensors& V/home/luca/screen-checking/.venv/lib/python3.14/site-packages/torch/export/_patches.py ,_clone_tensors_that_alias..s(& GS EHH  v{ 3 3|s-0TF)anycloneappendtuple)tensorscloned_tensors seen_tensorsrs& @r_clone_tensors_that_aliasr sNL  ##& GS& ###& GS& # # \\^Ff%      '   caaaaV^,pV^,oV'd V^,MRpV'd V^,MRo\V4^8Xd V^,M\V4^8Xd V^,MRoV^,P^4pV^,P^4p\PPP WV4oV'dSP ^4MSo\SSS34wooo\P!SP^4.\VPR,4O5RVPRVP/p V3Rlp VVVV3Rlp \P!^\PR7p \!WWWx.4wrppV'dVP ^4pWP#^4VP#^433#)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)) NNNdtypedevicec,<VSP^48#rsize)iouthxcxprecomputed_inputs&&&&rcond_fn*one_layer_while_loop_lstm..cond_fnA$))!,,,rc ><VP4p\P!V4\P!VSP^4^, R7\ SV,W#SSS^R7wr#VP 4pVP ^4W&V^,WV3#)rmax) chunk_dim)itemr _check_is_sizer'r rsqueeze) idxr)r*r+r(hh_bias hh_weight hr_weightr,s &&&& rbody_fn*one_layer_while_loop_lstm..body_fnDs HHJ Q Q$5$:$:1$=$AB a ")WiST iikAQw##rr")len unsqueezer nn functionallinearflipremptyr'rshaper"r#rint64r r6)inphiddenparams has_biasesreverse ih_weightih_biasr*r+ step_outputr-r;cnt_r)final_hxfinal_cxr8r9r:r,s&&&&& @@@@rone_layer_while_loop_lstmrSsq Iq I%fQi4G%fQi4G[A%q F q8H6!9d   Q B   Q B++2237K5<)..q1BS$= GY'%!Iw ++q! rxx| hhyy K- $ $ ,,q ,C!+3R4"AHhhhqk !!!$h&6&6q&9: ::rc \V4^8wd \R4h\W#V^,P^4V^,P^48g4p\ \ V^,V^,44p \ p \VV VVVVVVVV 4 wr\ \ V !4p V \P!V ^,^4\P!V ^,^43#)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) zlstm expects two hidden states) r>AssertionErrorrr'listziprSrr stack inputr*rIrJ num_layersdropouttrain bidirectional batch_firstrHlayer_fnr) final_hiddenss &&&&&&&&& rlstm_while_loop_implrb[s> 2w!|=>> 6r!uzz!}1 1 /M NF #beRU# $F(H$   Cm,-M  M!,a0%++mA>NPQ2R RRrcaaaV^,pV^,oV'd V^,MRpV'd V^,MRo\PPPWV4oV'dSP ^4MSo\ SS34wooVP ^4p\P!SP^4.\VPR,4O5RVPRVP/pV3Rlp VVV3Rlp \P!^\PR7p \WWV.4wrpV'dV P ^4p WP!^43#)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) Nr r"r#c,<VSP^48#r%r&)r(r) cur_hiddenr,s&&&rr-)one_layer_while_loop_gru..cond_fnr/rc6<VP4p\P!V4\P!VSP^4^, R7\ SV,VRRSS4pVP 4pVP ^4W&V^,W3#)rr1N)r4r r5r'rrr6)r7r)rer(r8r9r,s&&& rr;)one_layer_while_loop_gru..body_fns HHJ Q Q$5$:$:1$=$AB a *dD)W iik##A&Qw''rr=)r r@rArBrCrr?rDr'rrEr"r#rrFr r6)rGrHrIrJrKrLrMrerNr-r;rOrPr) final_hiddenr8r9r,s&&&&& @@@rone_layer_while_loop_grurjs9q Iq I%fQi4G%fQi4G++2237K5<)..q1BS2Iw3GHIw!!!$J++q! z# $  K- ( ,,q ,C%g:8VWALhhqk $$Q' ''rc \W#R4p\VP^44p \p \ VV VVVVVVVV 4 wrV \ P !V ^43#)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) F)rrVunbindrjrr rXrYs &&&&&&&&& rgru_while_loop_implrmsj>6u 5F "))A, F'H$   C  M1- --rc2V^8dQhR\R,/#return)NNNr)formats"r __annotate__rss,X,X ,Xrc#"\R,pVPVR4pVPP\PP P R4pWV&WP\PP P &RxVeW2V&MVPVR4Ve4VVP\PP P &R#VPP\PP P R4R# TeY2T&MTPTR4Te3TTP\PP P &iTPP\PP P R4i;i5i)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 r DispatchKeyCompositeImplicitAutogradpop)rnn_oprnn_implregistryoriginal_decomporiginal_py_kernels&& r&_register_rnn_while_loop_decompositionrsi*/:Hll640O **.. 66X#LT%((..HHI   &.V  LL &  )"   ehh22LL M    ! !%(("6"6"P"PRV W  &.V  LL &  )"   ehh22LL M    ! !%(("6"6"P"PRV Ws AF?!8D+BF?+BF<<F?c2V^8dQhR\R,/#ror)rrs"rrsrs(s :J0Krc#"\\PPPP \ 4;_uu_4RxRRR4R# +'giR#;i5i)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)rr opsatenlstmrZrbrr®ister_lstm_while_loop_decompositionr'sG0 0 !!#7       AA*A A* A' ! A*c2V^8dQhR\R,/#ror)rrs"rrsrsFsy9I/Jrc#"\\PPPP \ 4;_uu_4RxRRR4R# +'giR#;i5i)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)rr rrgrurZrmrrr%register_gru_while_loop_decompositionrEsG0 0   "5       r)F) contextlibcollections.abcrr torch._decomprtorch._decomp.decompositionsrrrr "torch._higher_order_ops.while_loopr rrSrbrjrmcontextmanagerrrrrrrrs% 4XX9 ! >;B1Sh4(n..b ,X,X^ : r