tj, ddlZddlmZddlZddlmZddlmZmZm Z m Z ddl m Z dZ ddZd Zdd Zd Zejd ed fdZejd ed fdZejd ed fdZdS)N) Generator)global_decomposition_table) _rnn_helper gather_paramsgru_cell lstm_cell) while_loopcg}g}|D]_/tfd|Dr||`t|S)Nc3XK|]$}tj|V%dS)N)torch_C _overlaps).0 seen_tensortensors S/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/torch/export/_patches.py z,_clone_tensors_that_alias..sF& & 8CEH  v{ 3 3& & & & & & )anycloneappendtuple)tensorscloned_tensors seen_tensorsrs @r_clone_tensors_that_aliasr sNL((  #& & & & GS& & & # # \\^^Ff%%%      ' ' '   rFc|d}|d|r|dnd}|r|dndt|dkr|dnt|dkr|dnd|dd}|dd}tjj||||rdntf\tj dgt|j ddR|j |j d} fd } fd } tjdtj } 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)) rNdtypedevicec6|dkSNrsize)iouthxcxprecomputed_inputs rcond_fnz*one_layer_while_loop_lstm..cond_fnA$))!,,,,rc T|}tj|tj|ddz t |||d\}}|}|d||<|dz|||fS)Nrrmaxr) chunk_dim)itemr _check_is_sizer)rrsqueeze) idxr+r,r-r*hh_bias hh_weight hr_weightr.s rbody_fnz*one_layer_while_loop_lstm..body_fnDs HHJJ Q Q$5$:$:1$=$=$ABBBB a "b)WiST   BiikkAAQwR##rr$)len unsqueezer nn functionallinearflipremptyr)rshaper$r%rint64r r7)inphiddenparams has_biasesreverse ih_weightih_biasr,r- step_outputr/r<cnt_r+final_hxfinal_cxr9r:r;r.s @@@@rone_layer_while_loop_lstmrSs"q Iq I%/fQii4G%/fQii4G[[A%%q F q8H8H6!99d   Q  B   Q  B+223 7KK5<S)..q111BS$= GY'%%!Iw +q!! rx|  hy K----- $ $ $ $ $ $ $ $ ,q , , ,C!+3 R4""AsHhhhqkk !!!$$h&6&6q&9&9: ::rc t|dkrtdt|||dd|ddk}t t |d|d} t } t|| |||||||| \} } t t | } | tj | ddtj | 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) rzlstm expects two hidden statesrr) r>AssertionErrorrr)listziprSrr stack inputr,rIrJ num_layersdropouttrain bidirectional batch_firstrHlayer_fnr+ final_hiddenss rlstm_while_loop_implrb[s> 2ww!||=>>> 6:r!uzz!}}1 1 /M N NF #beRU## $ $F(H$    Cm,--M  M!,a00%+mA>NPQ2R2R RRrc|d}|d|r|dnd}|r|dndtjj||||rdnt f\|d}tjdgt|j ddR|j |j d}fd} fd} tj dtj } t| | | ||g\} } }|r| 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) rrrNr r#c6|dkSr'r()r*r+ cur_hiddenr.s rr/z)one_layer_while_loop_gru..cond_fnr0rcH|}tj|tj|ddz t ||dd}|}|d||<|dz||fS)Nrrr2)r5r r6r)rrr7)r8r+rer*r9r:r.s rr<z)one_layer_while_loop_gru..body_fns HHJJ Q Q$5$:$:1$=$=$ABBBB a *dD)W  iikk##A&&AQwZ''rr=)r r@rArBrCrr?rDr)rrEr$r%rrFr r7)rGrHrIrJrKrLrMrerNr/r<rOrPr+ final_hiddenr9r:r.s @@@rone_layer_while_loop_grurhsq Iq I%/fQii4G%/fQii4G+223 7KK5<S)..q111BS2Iw3GHHIw!!!$$J+q!! z# $ $ K----- ( ( ( ( ( ( ( ,q , , ,C%gwk:8VWWAsLhhqkk  $$Q'' ''rc t||d}t|d} t} t || |||||||| \} } | t j| 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)rrVunbindrhrr rXrYs rgru_while_loop_implrks|>6:u 5 5F "))A,,  F'H$    C  M1-- --rreturn)NNNc#Ktd}||d}|jtjjjd} |||<||jtjjj<dV||||<n||d| ||jtjjj<dS|jtjjjddS#||||<n||d|||jtjjj<w|jtjjjdwxYw)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 r DispatchKeyCompositeImplicitAutogradpop)rnn_oprnn_implregistryoriginal_decomporiginal_py_kernels r&_register_rnn_while_loop_decompositionrysq*/:Hll6400O *.. 6X#LT%(.HI   &.HV   LL & & &  )"  eh2L M M M   ! !%("6"PRV W W W W W  &.HV   LL & & &  )"  eh2L M M   ! !%("6"PRV W W W Ws 'C..A0Ec#Kttjjjjt 5dVddddS#1swxYwYdS)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)ryr opsatenlstmrZrbrr®ister_lstm_while_loop_decompositionr's0 0 !#7   AA Ac#Kttjjjjt 5dVddddS#1swxYwYdS)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)ryr r{r|grurZrkr~rr%register_gru_while_loop_decompositionrEs0 0  "5   r)F) contextlibcollections.abcrr torch._decomprtorch._decomp.decompositionsrrrr"torch._higher_order_ops.while_loopr rrSrbrhrkcontextmanagerryrrr~rrrst%%%%%% 444444XXXXXXXXXXXX999999 ! ! ! >;>;>;>;B1S1S1Sh4(4(4(4(n......b ,X ,X,X,X,X^  :J0K: y9I/Jr