
    '}ht              )          d dl 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mZ d dl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'dee   dee   dee   dee   dee   dee   dee   dededee   dee   dee   dededededeeef   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e   dee   dee   dededededeeef   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e   dee   dee   dededededeeef   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e   dee   dee   dededededeeef   ded ed!ededed%df&d&Z y)(    )ListOptionalUnionTupleN)Tensor   )	OptimizerParamsT_use_grad_for_differentiable
_get_value_stack_if_compiling_dispatch_sqrt_default_to_fused_or_foreach_get_scalar_dtype_capturable_doc_differentiable_doc_foreach_doc
_fused_doc_maximize_doc_view_as_real)$_get_fused_kernels_supported_devicesAdamadamc                        e Zd Z	 	 	 	 	 ddddddddedeeef   deeef   deded	ed
e	e   dededede	e   f fdZ
 fdZd Zedd       Z xZS )r   FN)foreachmaximize
capturabledifferentiablefusedparamslrbetasepsweight_decayamsgradr   r   r   r   r   c                <   d|k  st        d|       t        |t              r|r|	st        d      d|k  st        d|       d|d   cxk  rdk  sn t        d|d          d|d   cxk  rdk  sn t        d	|d          d|k  st        d
|       t        ||||||||	|
|
      }t        |   ||       |rY|
rt        d      d| _        t               t        fd| j                  D              st        d d      |rt        d      y y )N        zInvalid learning rate: Elr as a Tensor is not supported for capturable=False and foreach=TruezInvalid epsilon value: r         ?z#Invalid beta parameter at index 0: r   z#Invalid beta parameter at index 1: zInvalid weight_decay value: )
r!   r"   r#   r$   r%   r   r   r   r   r   z)`fused` does not support `differentiable`Tc              3      K   | ]=  }|d    D ]3  }|j                   j                  v xr t        j                  |       5 ? yw)r    N)devicetypetorchis_floating_point).0pgpfused_supported_devicess      O/var/www/html/test/engine/venv/lib/python3.12/site-packages/torch/optim/adam.py	<genexpr>z Adam.__init__.<locals>.<genexpr>8   sZ      /1PRS[P\KL !88 +''*++s   AAzX`fused=True` requires all the params to be floating point Tensors of supported devices: .z0`fused` and `foreach` cannot be `True` together.)
ValueError
isinstancer   dictsuper__init__RuntimeError_step_supports_amp_scalingr   allparam_groups)selfr    r!   r"   r#   r$   r%   r   r   r   r   r   defaultsr2   	__class__s                @r3   r:   zAdam.__init__   sp    by6rd;<<b&!gjdeecz6se<==eAh$$B58*MNNeAh$$B58*MNNl";L>JKK2U%17!)7z'5UD 	*"#NOO.2D+
 'K&L# 595F5F  # $99P8QQR$T U U"#UVV      c                    t         |   |       | j                  D ]#  }|j                  dd       |j                  dd       |j                  dd        |j                  dd       |j                  dd       |j                  dd       }|d   D ]  }| j                  j                  |g       }t        |      d	k7  s.t        j                  |d
         rGt        |d
         }|d   s|d   r,t        j                  |t        |      |j                        nt        j                  |t                     |d
<    & y )Nr%   Fr   r   r   r   r   r    r   stepis_fuseddtyper+   rH   )r9   __setstate__r>   
setdefaultstategetlenr-   	is_tensorfloattensorr   r+   )r?   rL   groupr   r1   p_statestep_valrA   s          r3   rJ   zAdam.__setstate__A   s%   U#&& 	_EY.Z/Y-\51-u5$$Wd3E8_ _**..B/w<1$U__WV_-M$WV_5H*/*=w (-||HDU_dDenonvnv'w,1LLIZI\,] FO	_	_rB   c                 2   d}|d   D ]  }	|	j                   |t        j                  |	      z  }|j                  |	       |	j                   j                  rt        d      |j                  |	j                          | j                  |	   }
t        |
      dk(  r|d   s|d   r/t        j                  dt        |d         |	j                  	      nt        j                  d
t                     |
d<   t        j                  |	t        j                        |
d<   t        j                  |	t        j                        |
d<   |d   r(t        j                  |	t        j                        |
d<   |j                  |
d          |j                  |
d          |d   r|j                  |
d          |d   r|
d   j                  rt        d      |d   r(t        j                  |d         r|d   st        d      |j                  |
d           |S )NFr    zJAdam does not support sparse gradients, please consider SparseAdam insteadr   r   r    rE   rG   r'   rI   rD   )memory_formatexp_avg
exp_avg_sqr%   max_exp_avg_sqr   zB`requires_grad` is not supported for `step` in differentiable moder   r!   r(   )gradr-   
is_complexappend	is_sparser;   rL   rN   zerosr   r+   rQ   
zeros_likepreserve_formatrequires_gradrO   )r?   rR   params_with_gradgradsexp_avgsexp_avg_sqsmax_exp_avg_sqsstate_stepshas_complexr1   rL   s              r3   _init_groupzAdam._init_groupR   s    x '	2Avv!u//22 ''*66##&'sttQVV$

1u:? !.%. B.?w.Xabaiaij"\\#5F5HI &M (-'7'7I^I^'_E)$*/*:*:1ELaLa*bE,'Y'272B2B1TYTiTi2j./i 01""5#67##**51A+BC)*uV}/J/J&'kll #d(DUS_M`&'noo""5=1O'	2P rB   c                    | j                          d}|$t        j                         5   |       }ddd       | j                  D ]|  }g }g }g }g }g }g }	|d   \  }
}| j	                  |||||||	      }t        ||||||	f|d   ||
||d   |d   |d   |d   |d   |d	   |d
   |d   t        | dd      t        | dd      d ~ |S # 1 sw Y   xY w)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   
grad_scale	found_inf)r%   ri   beta1beta2r!   r$   r#   r   r   r   r   r   rl   rm   ) _cuda_graph_capture_health_checkr-   enable_gradr>   rj   r   getattr)r?   closurelossrR   rc   rd   re   rf   rg   rh   rn   ro   ri   s                r3   rD   z	Adam.step   s>    	--/""$ !y! && '	E!EHK OK >LE5** K   i(';">2%Lz*i( .$%56Gn"4t<!$T:)%'	R Y! !s   CC)gMbP?)g?g+?g:0yE>r   FN)__name__
__module____qualname__r
   r   rP   r   r   boolr   r:   rJ   rj   r   rD   __classcell__)rA   s   @r3   r   r      s     -1.:"'(!&0W ,0"'$)(-)-0W 0W5&=)0W eUl+0W 	0W
  %0W 0W #4.0W  0W "0W "&0W !0Wd_"3j "7 "7rB   a  Implements Adam algorithm.

    .. math::
       \begin{aligned}
            &\rule{110mm}{0.4pt}                                                                 \\
            &\textbf{input}      : \gamma \text{ (lr)}, \beta_1, \beta_2
                \text{ (betas)},\theta_0 \text{ (params)},f(\theta) \text{ (objective)}          \\
            &\hspace{13mm}      \lambda \text{ (weight decay)},  \: \textit{amsgrad},
                \:\textit{maximize}                                                              \\
            &\textbf{initialize} :  m_0 \leftarrow 0 \text{ ( first moment)},
                v_0\leftarrow 0 \text{ (second moment)},\: \widehat{v_0}^{max}\leftarrow 0\\[-1.ex]
            &\rule{110mm}{0.4pt}                                                                 \\
            &\textbf{for} \: t=1 \: \textbf{to} \: \ldots \: \textbf{do}                         \\

            &\hspace{5mm}\textbf{if} \: \textit{maximize}:                                       \\
            &\hspace{10mm}g_t           \leftarrow   -\nabla_{\theta} f_t (\theta_{t-1})         \\
            &\hspace{5mm}\textbf{else}                                                           \\
            &\hspace{10mm}g_t           \leftarrow   \nabla_{\theta} f_t (\theta_{t-1})          \\
            &\hspace{5mm}\textbf{if} \: \lambda \neq 0                                           \\
            &\hspace{10mm} g_t \leftarrow g_t + \lambda  \theta_{t-1}                            \\
            &\hspace{5mm}m_t           \leftarrow   \beta_1 m_{t-1} + (1 - \beta_1) g_t          \\
            &\hspace{5mm}v_t           \leftarrow   \beta_2 v_{t-1} + (1-\beta_2) g^2_t          \\
            &\hspace{5mm}\widehat{m_t} \leftarrow   m_t/\big(1-\beta_1^t \big)                   \\
            &\hspace{5mm}\widehat{v_t} \leftarrow   v_t/\big(1-\beta_2^t \big)                   \\
            &\hspace{5mm}\textbf{if} \: amsgrad                                                  \\
            &\hspace{10mm}\widehat{v_t}^{max} \leftarrow \mathrm{max}(\widehat{v_t}^{max},
                \widehat{v_t})                                                                   \\
            &\hspace{10mm}\theta_t \leftarrow \theta_{t-1} - \gamma \widehat{m_t}/
                \big(\sqrt{\widehat{v_t}^{max}} + \epsilon \big)                                 \\
            &\hspace{5mm}\textbf{else}                                                           \\
            &\hspace{10mm}\theta_t \leftarrow \theta_{t-1} - \gamma \widehat{m_t}/
                \big(\sqrt{\widehat{v_t}} + \epsilon \big)                                       \\
            &\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 `Adam: A Method for Stochastic Optimization`_.
    a  
    Args:
        params (iterable): iterable of parameters to optimize or dicts defining
            parameter groups
        lr (float, Tensor, optional): learning rate (default: 1e-3). A tensor LR
            is not yet supported for all our implementations. Please use a float
            LR if you are not also specifying fused=True or capturable=True.
        betas (Tuple[float, float], optional): coefficients used for computing
            running averages of gradient and its square (default: (0.9, 0.999))
        eps (float, optional): term added to the denominator to improve
            numerical stability (default: 1e-8)
        weight_decay (float, optional): weight decay (L2 penalty) (default: 0)
        amsgrad (bool, optional): whether to use the AMSGrad variant of this
            algorithm from the paper `On the Convergence of Adam and Beyond`_
            (default: False)
        z	
        z
    .. _Adam\: A Method for Stochastic Optimization:
        https://arxiv.org/abs/1412.6980
    .. _On the Convergence of Adam and Beyond:
        https://openreview.net/forum?id=ryQu7f-RZ

    r    rd   re   rf   rg   rh   r   r   r   r   rl   rm   ri   r%   rn   ro   r!   r$   r#   r   c                h   |	)|'t        | |d      \  }}|rt        |t              r|sd}|	d}	|d}t        j                  j                         st        d |D              st        d      |r)t        j                  j                         rt        d      |	r)t        j                  j                         rt        d      |	r%t        j                  j                         st        }n-|r%t        j                  j                         st        }nt        } || ||||||||||||||||
|       y)	znFunctional API that performs Adam algorithm computation.

    See :class:`~torch.optim.Adam` for details.
    NF)	use_fusedc              3   P   K   | ]  }t        |t        j                           y wru   )r7   r-   r   )r/   ts     r3   r4   zadam.<locals>.<genexpr>/  s     2dST:a3N2ds   $&zPAPI has changed, `state_steps` argument must contain a list of singleton tensorsz6torch.jit.script not supported with foreach optimizersz4torch.jit.script not supported with fused optimizers)r%   ri   rn   ro   r!   r$   r#   r   r   r   rl   rm   )r   r7   r   r-   _utilsis_compilingr=   r;   jitis_scripting_fused_adam_multi_tensor_adam_single_tensor_adam)r    rd   re   rf   rg   rh   r   r   r   r   rl   rm   ri   r%   rn   ro   r!   r$   r#   r   _funcs                         r3   r   r     s   > }1&.TYZ
7z"f-jG} <<$$&s2dXc2d/dmnn599))+STT'')QRRUYY++-	//1!"					 "&#rB   c       
            ||J t         j                  j                         rt        |t              sJ t        |       D ]-  \  }}|s||   n||    }||   }||   }||   }t         j                  j                         s9|r7|j                  r|j                  s|j                  r|j                  sJ d       |dz  }|dk7  r|j                  ||      }t        j                  |      rqt        j                  |      }t        j                  |      }t        j                  |      }|rt        j                  ||         ||<   t        j                  |      }|j                  |d|
z
         |j                  |      j                  ||j!                         d|z
         |s|r|}d|
|z  z
  }d||z  z
  }||z  }|j#                         }|j%                         }|ro|r||   j'                         }n||   }||   j)                  t        j*                  ||             ||   j%                         ||z  z  j-                  ||z        }n(|j%                         ||z  z  j-                  ||z        }|j/                  ||       nt1        |      }d|
|z  z
  }d||z  z
  }||z  }t3        |      }|rDt        j*                  ||   |||          ||   j%                         |z  j-                  |      }n"|j%                         |z  j-                  |      }|j/                  |||        |st        j                  | |         st        j4                  ||         ||<   0 y )NzGIf capturable=True, params and state_steps must be CUDA or XLA tensors.r   r   alpha)value)out)r-   r   r   r7   rP   	enumerater   r   is_cudais_xlaaddr\   view_as_reallerp_mul_addcmul_conjnegsqrtclonecopy_maximumadd_addcdiv_r   r   view_as_complex) r    rd   re   rf   rg   rh   rl   rm   r%   ri   rn   ro   r!   r$   r#   r   r   r   iparamr[   rX   rY   step_trD   bias_correction1bias_correction2	step_sizestep_size_negbias_correction2_sqrtrZ   denoms                                    r3   r   r   R  si   ( )"333yy "e$$$f% QK5'uQxeAhY1+ ^
Q ||((*z6>>u||YXYV 	!188E86DE"%%d+D((1G++J7J%*%7%78J%K"&&u-E 	dAI&''diikU'KD 5D=0 5D=0--I%MMOM$4$9$9$;!!%4Q%7%=%=%?N%4Q%7N"((~z)RS
 )+0026Km6[\bbcfivcvw#*.Cm.STZZ[^an[noNN7E*f%D 5D=0 5D=0--I$23C$D!oa0*/RSBTU )+0025JJPPQTU#*-BBHHMNN7E)N< u''q	2!&!6!6q7I!JOAcQKrB   c       
   	      X   t        |       dk(  ry t        |t              r|st        d      t        j
                  j                         s%|r#t        d t        | |      D              sJ d       ||J |rJ d       t        j                  | |||||g      }|j                         D ]i  \  \  }}}}}}}|	r |rt        |||||       nt        ||||       |rt	        j                  |      }|d   j                  r.t	        j                  |t	        j                   dd      d	       nt	        j                  |d
       |dk7  r3|rt	        j                  |||	       nt	        j"                  |||	      }t	        j$                  ||d
|
z
         t	        j&                  ||       t	        j(                  |||d
|z
         ~|rOt	        j*                  |
|      }t	        j*                  ||      }t	        j,                  |d
       t	        j,                  |d
       t	        j.                  |       t	        j0                  ||       t	        j2                  |       t	        j4                  |       |}|}|r,t	        j6                  ||       t	        j8                  |      }nt	        j8                  |      }t	        j0                  ||       t	        j                  ||       t	        j0                  ||       t	        j:                  |||       p|D cg c]  }d
|
t=        |      z  z
   }}|D cg c]  }d
|t=        |      z  z
   }}t?        |D  cg c]
  } || z  dz   c}       }|D  cg c]  } tA        |        }} |r,t	        j6                  ||       t	        j8                  |      }nt	        j8                  |      }t	        j0                  ||       t	        j                  ||       t	        j:                  ||||       l y c c}w c c}w c c} w c c} w )Nr   r(   c              3   V   K   | ]!  \  }}|j                   xr |j                    # y wru   )r   )r/   r1   rD   s      r3   r4   z%_multi_tensor_adam.<locals>.<genexpr>  s$     V'!T199--Vs   ')z@If capturable=True, params and state_steps must be CUDA tensors.z#_foreach ops don't support autogradr)   cpu)r+   r   r   )!rN   r7   r   r;   r-   r   r   r=   zipr	   "_group_tensors_by_device_and_dtypevaluesr   _foreach_negis_cpu_foreach_add_rQ   _foreach_add_foreach_lerp__foreach_mul__foreach_addcmul__foreach_pow_foreach_sub__foreach_neg__foreach_div__foreach_reciprocal__foreach_sqrt__foreach_maximum__foreach_sqrt_foreach_addcdiv_r   r   r   )!r    rd   re   rf   rg   rh   rl   rm   r%   ri   rn   ro   r!   r$   r#   r   r   r   grouped_tensorsdevice_paramsdevice_gradsdevice_exp_avgsdevice_exp_avg_sqsdevice_max_exp_avg_sqsdevice_state_stepsr   r   r   r   r   exp_avg_sq_sqrtrD   bcs!                                    r3   r   r     s   & 6{a"fjbcc <<$$&:VS=UVV 	ON	OV )"333DDDBB	+LNO ##%c` 	
 
 m\?L^`vwm\?L^_ --l;L a '' 2ELLU4S[^_ 2A61##L-|T$11,Uab 	_lAIF.6 2L,PQTYPYZ $11%9KL$11%9KL 0!4 0!4 01  0"5&&'78  !12
 )I$4!''(>@RS #("5"56L"M"'"5"56H"I1FG5; ##M?OTJ\]$EZ-=$= =]]J\]$EZ-=$= =]]+FV,Wb2g^,WXIBR$SB^B%7$S!$S''(>@RS #("5"56L"M"'"5"56H"I1FG5##M?OU^_Gc`b  ^],W$Ss   P<PP"
9P'returnc       
            | sy |rt        d      ||j                  |ind }||j                  |ind }t        |t              r&t	        |j                        dk7  r|j                  |ind }t        j                  | |||||g      }|j                         D ]  \  \  }}\  \  }}}}}}}d\  }}|||vr|j                  |d      ||<   ||   }|||vr|j                  |d      ||<   ||   }|||vr|j                  |d      ||<   ||   }t        j                  |d       t        j                  |||||||||
||||||       |t        j                  ||gt        |      z          y )	Nz9Adam with fused=True does not support differentiable=Truer   )NNT)non_blocking)r+   r   r   )	r%   r!   rn   ro   r$   r#   r   rl   rm   )r;   r+   r7   r   strr	   r   itemstor-   r   _fused_adam_r   rN   ) r    rd   re   rf   rg   rh   rl   rm   r%   ri   rn   ro   r!   r$   r#   r   r   r   grad_scale_dictfound_inf_dictlr_dictr   r+   r   r   r   r   r   r   r   device_grad_scaledevice_found_infs                                    r3   r   r   L  s   * VWW9C9Oz((*5UYO6?6Ki&&	2QUN ",B!7C		Ne<Sryy"oY]GBB	+LNO 4C3H3H3J%b 	0 0 ,}#&)-)Q.8++!_,*4--T-*R' / 7 .)2f4)Pv&-f56#8 ee6eEGFOB.2"%(&	
" ' 25E4FM_I`4`aK%brB   )NFFNNNF)!typingr   r   r   r   r-   r   	optimizerr	   r
   r   r   r   r   r   r   r   r   r   r   r   r   torch.utils._foreach_utilsr   __all__r   __doc__ry   rP   r   r   r   r   rV   rB   r3   <module>r      s   / /  B B B B L6
q9 qh&L	 
 		 		 		 		 'M?T $(! %!%(,'+"Kf KVK<K 6lK v,	K
 6lK 4.K K K K f%K V$K K  !K" #K$ %K& 5&=!'K( )K* +K, -K\mKV mK#F|mK"&v,mK &*&\mK *.f	mK
 &*&\mK %-V$4mK $,F#3mK "&mK &*mK  %mK  %mK "%-0mK ',mK #mK  #'!mK" %)#mK$ )-%mK`G`tF| G`"6lG`!%fG` %)LG` )-V	G`
 %)LG` $,F#3G` #+6"2G` !%G` %)G` $G` $G` !/G` &+G` "G`  "&!G`" $(#G`$ (,%G`THbLHb<Hb 6lHb f	Hb
 &\Hb fHb  Hb Hb Hb Hb Hb Hb 	eVmHb Hb  
!Hb" #Hb$ %Hb& 'Hb( 
)HbrB   