o ei*@sddlZddlmZddlZddlmZddlmZmZm Z m Z ddl m Z dddZ d d Zdd d Zd dZejdedfddZejdedfddZejdedfddZdS)N) Generator)global_decomposition_table) _rnn_helper gather_paramsgru_cell lstm_cell) while_loopFcs>|d}|d|r|dnd}|r|dndt|dkr"|dn t|dkr,|dnd|dd}|dd}tjj||||rLdntjdgt |j ddR|j |j d} fd d } fd d } tj dtjd } t| | | | ||g\} }}}|r|d}||d|dffS)ay 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|dkSNrsize)iouthxcxprecomputed_input_/var/www/addictedbytheproject.nl/epg/venv/lib/python3.10/site-packages/torch/export/_patches.pycond_fn.z*one_layer_while_loop_lstm..cond_fnc sn|}t|tj|dddt|||dd\}}|}|d||<|d|||fS)Nrr maxr ) chunk_dim)itemtorch_check_is_sizerrclonesqueeze)idxrrrrhh_bias hh_weight hr_weightrrrbody_fn1s  z*one_layer_while_loop_lstm..body_fnr)len unsqueezer#nn functionallinearflipemptyrtupleshaperrtensorint64rr&)inphiddenparams has_biasesreverse ih_weightih_biasrr step_outputrr,cnt_rfinal_hxfinal_cxrr(rone_layer_while_loop_lstm s6*    rEc Cst|dkr tdt|||dd|ddk}tt|d|d} t} t|| |||||||| \} } tt| } | t | ddt | ddfS)a 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 ) r.AssertionErrorrrlistziprErr#stack inputrr;r< num_layersdropouttrain bidirectional batch_firstr:layer_fnr final_hiddensrrrlstm_while_loop_implIs& $ "rSc s|d|d|r|dnd|r|dndtjj||r(dn|d}tjdgt|j ddR|j |j d}fdd}fd d }tj dtj d } t||| ||g\} } } |rs| d} | | dfS) ad 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 rcrrr)rr cur_hiddenrrrrrz)one_layer_while_loop_gru..cond_fncsd|}t|tj|dddt||}|}|d||<|d||fS)Nrr r)r"r#r$rrr%r&)r'rrTrr)r*r?r>rrrr,s z)one_layer_while_loop_gru..body_fnr-)r#r0r1r2r3r/r4rr5r6rrr7r8rr&) r9r:r;r<r=rTr@rr,rArBr final_hiddenrrUrone_layer_while_loop_gru}s,    rWc CsLt||d}t|d} t} t|| |||||||| \} } | t| dfS)a 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)rrGunbindrWrr#rIrJrrrgru_while_loop_impls  rYreturn)NNNc cstd}||d}|jtjjjd}z9|||<||jtjjj<dVW|dur/|||<n||d|durC||jtjjj<dS|jtjjjddS|durX|||<n||d|durk||jtjjj<w|jtjjjdw)a 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_kernelrrr&_register_rnn_while_loop_decompositions0      rgcc@ttjjjjt dVWddS1swYdS)a 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)rgr#opsatenlstmrKrSrrrr®ister_lstm_while_loop_decomposition  "rlccrh)a 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)rgr#rirjgrurKrYrrrr%register_gru_while_loop_decomposition2rmro)F) contextlibcollections.abcrr# torch._decomprtorch._decomp.decompositionsrrrr"torch._higher_order_ops.while_looprrErSrWrYcontextmanagerrgrlrorrrrs$    ? 461 /