
    Χg@                     j   d dl mZmZmZmZmZmZ d dlZd dlmZ ddl	m
Z
mZmZmZmZmZmZmZmZmZmZmZ ddgZ G d de          Zd	d
e de
 de de d	z   e_        dee         dee         dee         dee         dee         dedededededededefdZdee         dee         dee         dee         dee         dedededededededefdZ ee          	 	 	 	 d dee         dee         dee         dee         dee         dedee         dededededededefd            ZdS )!    )AnycastDictListOptionalUnionN)Tensor   )_capturable_doc_default_to_fused_or_foreach_differentiable_doc_disable_dynamo_if_unsupported_foreach_doc!_get_capturable_supported_devices_get_scalar_dtype_maximize_doc_use_grad_for_differentiable_view_as_real	OptimizerParamsTAdadeltaadadeltac                       e Zd Z	 	 	 	 	 dddddded	eeef         d
edededee         dededef fdZ	 fdZ
deeef         dee         dee         dee         dee         dee         fdZedd            Z xZS )r         ??ư>r   NF)
capturablemaximizedifferentiableparamslrrhoepsweight_decayforeachr   r   r   c          
         t          |t                    r'|                                dk    rt          d          d|k    st          d|           d|cxk    rdk    sn t          d|           d|k    st          d|           d|k    st          d|           t	          ||||||||		          }
t                                          ||
           d S )
Nr
   zTensor lr must be 1-elementg        zInvalid learning rate: r   zInvalid rho value: zInvalid epsilon value: zInvalid weight_decay value: )r!   r"   r#   r$   r   r   r%   r   )
isinstancer	   numel
ValueErrordictsuper__init__)selfr    r!   r"   r#   r$   r%   r   r   r   defaults	__class__s              P/var/www/html/ai-engine/env/lib/python3.11/site-packages/torch/optim/adadelta.pyr,   zAdadelta.__init__   s    b&!! 	<bhhjjAoo:;;;byy;r;;<<<c    S    8388999czz<s<<===l""JLJJKKK%!)	
 	
 	
 	*****    c                    t                                          |           | j        D ]}|                    dd            |                    dd           |                    dd           |                    dd           |d         D ]}| j                            |g           }t          |          dk    rt          j        |d                   sjt          |d                   }|d         r(t          j
        |t                      |j        	          n!t          j
        |t                      
          |d<   d S )Nr%   r   Fr   r   r    r   stepdtypedevicer5   )r+   __setstate__param_groups
setdefaultstategetlentorch	is_tensorfloattensorr   r6   )r-   r;   grouppp_statestep_valr/   s         r0   r8   zAdadelta.__setstate__@   sO   U###& 	 	EY---Z///-u555\51118_ 
 
*..B//w<<1$$U_WV_-M-M$$WV_55H
 !.O$,=,?,?    #\(:K:M:MNNN FO	
	 	r1   rB   params_with_gradgradssquare_avgs
acc_deltasstate_stepsc                    d}|d         D ]x}|j         |t          j        |          z  }|                    |           |j         j        rt          d          |                    |j                    | j        |         }	t          |	          dk    r|d         r(t          j        dt                      |j
                  n!t          j        dt                                |	d	<   t          j        |t          j        
          |	d<   t          j        |t          j        
          |	d<   |                    |	d                    |                    |	d                    |                    |	d	                    z|S )NFr    z*Adadelta does not support sparse gradientsr   r    r4   r7   r3   )memory_format
square_avg	acc_delta)gradr>   
is_complexappend	is_sparseRuntimeErrorr;   r=   zerosr   r6   
zeros_likepreserve_format)
r-   rB   rF   rG   rH   rI   rJ   has_complexrC   r;   s
             r0   _init_groupzAdadelta._init_groupS   s    x 	. 	.Av~5+A...K##A&&&v Q"#OPPPLL   JqME 5zzQ \*DEK*;*=*=ahOOOOR/@/B/BCCC f ',&6U%:' ' 'l# &+%5U%:& & &k" u\2333eK0111uV}----r1   c                    |                                   d}|5t          j                    5   |            }ddd           n# 1 swxY w Y   | j        D ]}g }g }g }g }g }|d         |d         |d         |d         |d         |d         |d         |d	         f\  }	}
}}}}}}|                     ||||||          }t          ||||||	|
|||||||
           |S )zPerform a single optimization step.

        Args:
            closure (Callable, optional): A closure that reevaluates the model
                and returns the loss.
        Nr!   r"   r#   r$   r%   r   r   r   )	r!   r"   r#   r$   r%   r   r   r   rX   ) _cuda_graph_capture_health_checkr>   enable_gradr9   rY   r   )r-   closurelossrB   rF   rG   rH   rI   rJ   r!   r"   r#   r$   r%   r   r   r   rX   s                     r0   r3   zAdadelta.step~   s    	--///"$$ ! !wyy! ! ! ! ! ! ! ! ! ! ! ! ! ! ! & -	 -	E-/"$E(*K')J(*K deen%i j!&'l#		 **'Z K  )!-%'    " s   AA
A)r   r   r   r   NN)__name__
__module____qualname__r   r   r@   r	   r   boolr,   r8   r   strr   r   rY   r   r3   __classcell__)r/   s   @r0   r   r      ss        $'"&"+ !$"+ "+ "+"+ %- "+ 	"+
 "+ "+ $"+ "+ "+ "+ "+ "+ "+ "+ "+H    &)CH~) v,) F|	)
 &\) L) &\) ) ) )V "= = = "!= = = = =r1   a  Implements Adadelta algorithm.

    .. math::
       \begin{aligned}
            &\rule{110mm}{0.4pt}                                                                 \\
            &\textbf{input}      : \gamma \text{ (lr)}, \: \theta_0 \text{ (params)},
                \: f(\theta) \text{ (objective)}, \: \rho \text{ (decay)},
                \: \lambda \text{ (weight decay)}                                                \\
            &\textbf{initialize} :  v_0  \leftarrow 0 \: \text{ (square avg)},
                \: u_0 \leftarrow 0 \: \text{ (accumulate variables)}                     \\[-1.ex]
            &\rule{110mm}{0.4pt}                                                                 \\
            &\textbf{for} \: t=1 \: \textbf{to} \: \ldots \: \textbf{do}                         \\
            &\hspace{5mm}g_t           \leftarrow   \nabla_{\theta} f_t (\theta_{t-1})           \\
            &\hspace{5mm}if \: \lambda \neq 0                                                    \\
            &\hspace{10mm} g_t \leftarrow g_t + \lambda  \theta_{t-1}                            \\
            &\hspace{5mm} v_t      \leftarrow v_{t-1} \rho + g^2_t (1 - \rho)                    \\
            &\hspace{5mm}\Delta x_t    \leftarrow   \frac{\sqrt{u_{t-1} +
                \epsilon }}{ \sqrt{v_t + \epsilon}  }g_t \hspace{21mm}                           \\
            &\hspace{5mm} u_t  \leftarrow   u_{t-1}  \rho +
                 \Delta x^2_t  (1 - \rho)                                                        \\
            &\hspace{5mm}\theta_t      \leftarrow   \theta_{t-1} - \gamma  \Delta x_t            \\
            &\rule{110mm}{0.4pt}                                                          \\[-1.ex]
            &\bf{return} \:  \theta_t                                                     \\[-1.ex]
            &\rule{110mm}{0.4pt}                                                          \\[-1.ex]
       \end{aligned}

    For further details regarding the algorithm we refer to `ADADELTA: An Adaptive Learning Rate Method`_.
    a  
    Args:
        params (iterable): iterable of parameters to optimize or dicts defining
            parameter groups
        rho (float, optional): coefficient used for computing a running average
            of squared gradients (default: 0.9). A higher value of `rho` will
            result in a slower average, which can be helpful for preventing
            oscillations in the learning process.
        eps (float, optional): term added to the denominator to improve
            numerical stability (default: 1e-6).
        lr (float, Tensor, optional): coefficient that scale delta before it is applied
            to the parameters (default: 1.0)
        weight_decay (float, optional): weight decay (L2 penalty) (default: 0)
        z	
        zd

    .. _ADADELTA\: An Adaptive Learning Rate Method:
        https://arxiv.org/abs/1212.5701

    r    rG   rH   rI   rJ   r!   r"   r#   r$   r   r   r   rX   c                T   t           j                                        sI|rGt          d          t	          fdt          | |          D                       sJ d d            t          | ||||          D ]\  }}}}}|dz  }|	s|n| }|dk    r|                    ||          }t          j        |          r<t          j        |          }t          j        |          }t          j        |          }|	                    |          
                    ||d|z
  	           |                    |                                          }|                    |                                          }|
r|                                }|                    |          	                    |           |	                    |          
                    ||d|z
  	           t          j        |          rt          j        |          }|                    ||            d S )
NFsupports_xlac              3   n   K   | ]/\  }}|j         j        |j         j        k    o|j         j        v V  0d S r_   r6   type.0rC   r3   capturable_supported_devicess      r0   	<genexpr>z*_single_tensor_adadelta.<locals>.<genexpr>
  ]       
 
 4 HMT[-- >!==
 
 
 
 
 
r1   IIf capturable=True, params and state_steps must be on supported devices: .r
   r   alphavalue)r>   _utilsis_compilingr   allzipaddrQ   view_as_realmul_addcmul_sqrt_clonediv_view_as_complexadd_)r    rG   rH   rI   rJ   r!   r"   r#   r$   r   r   r   rX   paramrP   rN   rO   r3   stddeltarn   s                       @r0   _single_tensor_adadeltar      sg   " <$$&& w: w'H(
 (
 (
$  
 
 
 
 v{33
 
 
 
 
 	w 	w wWsvvv		w 	w 	w 58{J5 5 % %0tZD 		#.tt$188E866DE"" 	,+J77J*955I%d++D%%dDC%@@@nnS!!''))c""((** 	"KKMME

3T"""s$$UES$AAAE"" 	1)%00E

5
$$$$1% %r1   c                   |
r
J d            t           j                                        sI|rGt          d          t	          fdt          | |          D                       sJ d d            t          |           dk    rd S t          j        | ||||g          }|	                                D ]\  \  }}}}}}t          t          t                   |          }t          t          t                   |          }t          t          t                   |          }t          t          t                   |          }t          t          t                   |          }|rt          ||||           t           j                                        s9|d         j        r,t          j        |t          j        dd	
          d           nt          j        |d           |	rt          j        |          }|dk    r1|	rt          j        |||           nt          j        |||          }t          j        ||           t          j        |||d|z
             t          j        ||          }t          j        |           t          j        ||          }t          j        |           t          j        ||           t          j        ||           t          j        ||           t          j        |||d|z
             |rGt/          |t           j                  r-t          j        ||            t          j        ||           t          j        |||            d S )Nz#_foreach ops don't support autogradFrg   c              3   n   K   | ]/\  }}|j         j        |j         j        k    o|j         j        v V  0d S r_   rj   rl   s      r0   ro   z)_multi_tensor_adadelta.<locals>.<genexpr>B  rp   r1   rq   rr   r   r   cpu)r6   rs   r
   ru   )r>   rw   rx   r   ry   rz   r=   r   "_group_tensors_by_device_and_dtypevaluesr   r   r	   r   is_cpu_foreach_add_rA   _foreach_neg_foreach_add_foreach_mul__foreach_addcmul__foreach_sqrt__foreach_div_r'   )r    rG   rH   rI   rJ   r!   r"   r#   r$   r   r   r   rX   grouped_tensorsdevice_params_device_grads_device_square_avgs_device_acc_deltas_device_state_steps__device_paramsdevice_gradsdevice_square_avgsdevice_acc_deltasdevice_state_stepsr   deltasrn   s                              @r0   _multi_tensor_adadeltar   +  s     DDDDDD <$$&& w: w'H(
 (
 (
$  
 
 
 
 v{33
 
 
 
 
 	w 	w wWsvvv		w 	w 	w 6{{aB	Z= O ""$$>B >B 		 	T&\>::DL-88!$v,0CDD f/ABB!$v,0CDD 	|-?AR   |((** 	7/A!/D/K 	7"ELU$C$C$C3      2A666 	< -l;;L1 #L-|TTTTT$1 -|      	.444l!c'	
 	
 	
 	
  !3S99S!!!#$5s;;V$$$FC(((FL111-s333 166SQQQQ  	B*R66 	B,,,v6666vbSAAAAA}>B >Br1   )single_tensor_fnFr%   c	                   t           j                                        s(t          d |D                       st	          d          |t          | |d          \  }}|r-t           j                                        rt	          d          |r&t           j                                        st          }nt          } || |||||	|
||||||           dS )zvFunctional API that performs Adadelta algorithm computation.

    See :class:`~torch.optim.Adadelta` for details.
    c              3   J   K   | ]}t          |t          j                  V  d S r_   )r'   r>   r	   )rm   ts     r0   ro   zadadelta.<locals>.<genexpr>  s?       3 3()
1el##3 3 3 3 3 3r1   zPAPI has changed, `state_steps` argument must contain a list of singleton tensorsNF)	use_fusedz6torch.jit.script not supported with foreach optimizers)r!   r"   r#   r$   r   r   r   rX   )
r>   rw   rx   ry   rT   r   jitis_scriptingr   r   )r    rG   rH   rI   rJ   r   r%   r   rX   r!   r"   r#   r$   r   r   funcs                   r0   r   r     s'   6 <$$&& 
s 3 3-83 3 3 0 0 
 ^
 
 	

 1Ne
 
 

7  U59))++ USTTT 'uy--// '%&D!%     r1   )FNFF)typingr   r   r   r   r   r   r>   r	   	optimizerr   r   r   r   r   r   r   r   r   r   r   r   __all__r   __doc__r@   rc   r   r   r   rL   r1   r0   <module>r      s   : 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9                                    z
"a a a a ay a a aJ8 
  
  
   
!  91 	 l3%L3%<3% f3% V	3%
 f3% 	3% 
3% 
3% 3% 3% 3% 3% 3% 3% 3% 3%laBLaB<aB faB V	aB
 faB 	aB 
aB 
aB aB aB aB aB aB aB aB aBH  1HIII " = =L=<= f= V	=
 f= = d^= = = 	= 
= 
=  !=" #= = = JI= = =r1   