
    iriA                      n   d dl 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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dd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dd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dz  dedededededededdfd!            ZdS )#    )AnycastN)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
_to_scalar_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z  d
ededededz  dedededd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   returnc          	         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|           ||||||||	d	}
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super__init__)selfr   r   r    r!   r"   r#   r   r   r   defaults	__class__s              l/var/www/html/bestrading.cuttalo.com/models/btc_v9/venv/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r3   )r)   __setstate__param_groups
setdefaultstategetlentorch	is_tensorfloattensorr   r4   )r+   r9   grouppp_statestep_valr-   s         r.   r6   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	
	 	r/   r@   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    r2   r5   r1   )memory_format
square_avg	acc_delta)gradr<   
is_complexappend	is_sparseRuntimeErrorr9   r;   zerosr   r4   
zeros_likepreserve_format)
r+   r@   rD   rE   rF   rG   rH   has_complexrA   r9   s
             r.   _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}----r/   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   rV   ) _cuda_graph_capture_health_checkr<   enable_gradr7   rW   r   )r+   closurelossr@   rD   rE   rF   rG   rH   r   r    r!   r"   r#   r   r   r   rV   s                     r.   r1   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   boolr*   r6   dictstrr   listrW   r   r1   __classcell__)r-   s   @r.   r   r      sx        !#"+ !$"+ "+ "+"+ FN"+ 	"+
 "+ "+ "+ "+ "+ "+ 
"+ "+ "+ "+ "+ "+H    &)CH~) v,) F|	)
 &\) L) &\) ) ) )V "= = = "!= = = = =r/   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   rE   rF   rG   rH   r   r    r!   r"   r   r   r   rV   r$   c                   t           j                                        sP|rNt          d          t	          fdt          | |d          D                       st          d d          t           j                                        st          |          }t          | ||||d          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]   r4   type.0rA   r1   capturable_supported_devicess      r.   	<genexpr>z*_single_tensor_adadelta.<locals>.<genexpr>
  ]       
 
 4 HMT[-- >!==
 
 
 
 
 
r/   TstrictIIf capturable=True, params and state_steps must be on supported devices: .r   r   alphavalue)r<   compileris_compilingr   allzipAssertionErrorjitis_scriptingr   addrO   view_as_realmul_addcmul_sqrt_clonediv_view_as_complexadd_)r   rE   rF   rG   rH   r   r    r!   r"   r   r   r   rV   paramrN   rL   rM   r1   stddeltarn   s                       @r.   _single_tensor_adadeltar      s   " >&&(( Z 'H(
 (
 (
$  
 
 
 
 v{4@@@
 
 
 
 
 	
 !{\x{{{   9!!## ^^47{JD5 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% %r/   c                   |
rt          d          t          j                                        sP|rNt	          d          t          fdt          | |d          D                       st          d d          t          |           d	k    rd S t          |          }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
             |rGt3          |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      r.   ro   z)_multi_tensor_adadelta.<locals>.<genexpr>I  rp   r/   Trq   rs   rt   r   r   cpu)r4   ru   r   rw   )r}   r<   ry   rz   r   r{   r|   r;   r   r   "_group_tensors_by_device_and_dtypevaluesr   rd   r   r   is_cpu_foreach_add_r?   _foreach_neg_foreach_add_foreach_mul__foreach_addcmul__foreach_sqrt__foreach_div_r&   )r   rE   rF   rG   rH   r   r    r!   r"   r   r   r   rV   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                              @r.   _multi_tensor_adadeltar   1  s      DBCCC >&&(( Z 'H(
 (
 (
$  
 
 
 
 v{4@@@
 
 
 
 
 	
 !{\x{{{   6{{a	BB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r/   )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     r.   ro   zadadelta.<locals>.<genexpr>  s?       5 5()
1el##5 5 5 5 5 5r/   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   rV   )
r<   ry   rz   r{   rR   r   r~   r   r   r   )r   rE   rF   rG   rH   r   r#   r   rV   r   r    r!   r"   r   r   funcs                   r.   r   r     s'   6 >&&(( 
 5 5-85 5 5 2 2 
 ^
 
 	

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

7  U59))++ USTTT 'uy--// '%&D!%     r/   )FNFF)typingr   r   r<   r   	optimizerr   r   r	   r
   r   r   r   r   r   r   r   r   r   r   __all__r   __doc__rd   r>   ra   r   r   r   rJ   r/   r.   <module>r      s                                                $ z
"a a a a ay a a aJ8	  
  
  
  
  90 	 j9%L9%<9% f9% V	9%
 f9% 	9% 
9% 
9% 9% 9% 9% 9% 9% 
9% 9% 9% 9%xgBLgB<gB fgB V	gB
 fgB 	gB 
gB 
gB gB gB gB gB gB 
gB gB gB gBT  1HIII  = =L=<= f= V	=
 f= = D[= = = 	= 
= 
=  !=" #=$ 
%= = = JI= = =r/   