
    wi@                     t   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mZ ddgZ G d de          Zd	d
e 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_params_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              d/root/.openclaw/workspace/chatterbox_venv_py311/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r6   )r,   __setstate__param_groups
setdefaultstategetlentorch	is_tensorfloattensorr   r7   )r.   r<   grouppp_statestep_valr0   s         r1   r9   zAdadelta.__setstate__A   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	
	 	r2   rC   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    r5   r8   r4   )memory_format
square_avg	acc_delta)gradr?   
is_complexappend	is_sparseRuntimeErrorr<   r>   zerosr   r7   
zeros_likepreserve_format)
r.   rC   rG   rH   rI   rJ   rK   has_complexrD   r<   s
             r1   _init_groupzAdadelta._init_groupT   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}----r2   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   rY   ) _cuda_graph_capture_health_checkr?   enable_gradr:   rZ   r   )r.   closurelossrC   rG   rH   rI   rJ   rK   r"   r#   r$   r%   r&   r   r    r   rY   s                     r1   r4   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   rA   r	   r   boolr-   r9   r   strr   r   rZ   r   r4   __classcell__)r0   s   @r1   r   r      ss        $'"&"+ !$"+ "+ "+"+ %- "+ 	"+
 "+ "+ $"+ "+ "+ "+ "+ "+ "+ "+ "+H    &)CH~) v,) F|	)
 &\) L) &\) ) ) )V "= = = "!= = = = =r2   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`_.
    z
    Args:
        ar  
        lr (float, Tensor, optional): coefficient that scale delta before it is applied
            to the parameters (default: 1.0)
        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).
        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!   rH   rI   rJ   rK   r"   r#   r$   r%   r   r    r   rY   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`   r7   type.0rD   r4   capturable_supported_devicess      r1   	<genexpr>z*_single_tensor_adadelta.<locals>.<genexpr>
  ]       
 
 4 HMT[-- >!==
 
 
 
 
 
r2   IIf capturable=True, params and state_steps must be on supported devices: .r
   r   alphavalue)r?   compileris_compilingr   allzipaddrR   view_as_realmul_addcmul_sqrt_clonediv_view_as_complexadd_)r!   rH   rI   rJ   rK   r"   r#   r$   r%   r   r    r   rY   paramrQ   rO   rP   r4   stddeltaro   s                       @r1   _single_tensor_adadeltar      sf   " >&&(( wZ w'H(
 (
 (
$  
 
 
 
 v{33
 
 
 
 
 	w 	w wWsvvv		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% %r2   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 autogradFrh   c              3   n   K   | ]/\  }}|j         j        |j         j        k    o|j         j        v V  0d S r`   rk   rm   s      r1   rp   z)_multi_tensor_adadelta.<locals>.<genexpr>B  rq   r2   rr   rs   r   r   cpu)r7   rt   r
   rv   )r?   rx   ry   r   rz   r{   r>   r   "_group_tensors_by_device_and_dtypevaluesr   r   r	   r   is_cpu_foreach_add_rB   _foreach_neg_foreach_add_foreach_mul__foreach_addcmul__foreach_sqrt__foreach_div_r(   )r!   rH   rI   rJ   rK   r"   r#   r$   r%   r   r    r   rY   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   deltasro   s                              @r1   _multi_tensor_adadeltar   +  s     DDDDD >&&(( wZ w'H(
 (
 (
$  
 
 
 
 v{33
 
 
 
 
 	w 	w wWsvvv		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   ~**,, 	71CA1F1M 	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r2   )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	   )rn   ts     r1   rp   zadadelta.<locals>.<genexpr>  s?       5 5()
1el##5 5 5 5 5 5r2   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   rY   )
r?   rx   ry   rz   rU   r   jitis_scriptingr   r   )r!   rH   rI   rJ   rK   r   r&   r    rY   r"   r#   r$   r%   r   r   funcs                   r1   r   r     s'   6 >&&(( 
 5 5-85 5 5 2 2 
 ^
 
 	

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

7  U59))++ USTTT 'uy--// '%&D!%     r2   )FNFF)typingr   r   r   r   r   r   r?   r	   	optimizerr   r   r   r   r   r   r   r   r   r   r   r   r   __all__r   __doc__rA   rd   r   r   r   rM   r2   r1   <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	  
  
  
  
  90 	 j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= = =r2   