
    Phq              )          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l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eef   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e   dee   dee   dedededeeef   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e   dee   dee   dedededeeef   ded ed!edededed%df&d&Zy)(    N)Tensor   )	Optimizer_use_grad_for_differentiable
_get_value_dispatch_sqrt_stack_if_compiling_capturable_doc_differentiable_doc_foreach_doc
_fused_doc_maximize_doc_default_to_fused_or_foreachParamsT_view_as_real)ListOptionalTupleUnion)$_get_fused_kernels_supported_devicesAdamWadamwc                        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de	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)maximizeforeach
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      \C:\Users\daisl\Desktop\realtime-object-detection\venv\Lib\site-packages\torch/optim/adamw.py	<genexpr>z!AdamW.__init__.<locals>.<genexpr>?   sQ       ,BR\ !88 +''*+5A++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   defaultsr1   	__class__s                @r2   r9   zAdamW.__init__   sx    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%!)
 	*"#NOO.2D+
 'K&L#  ++ 
 # $99P8QQR$T U U"#UVV !     c                 6   t         |   |       | j                  D ]n  }|j                  dd       |j                  dd       |j                  dd        |j                  dd       |j                  dd       |j                  dd        p t	        | j
                  j                               }t        |      dk7  xr t        j                  |d   d	         }|s<|D ]6  }t        j                  t        |d	         t        j                  
      |d	<   8 y y )Nr$   Fr   r   r   r   r   r   stepdtype)r8   __setstate__r=   
setdefaultliststatevalueslenr,   	is_tensortensorfloatfloat32)r>   rI   groupstate_valuesstep_is_tensorsr@   s         r2   rF   zAdamW.__setstate__I   s    U#&&EY.Z/Y-\51-u5Wd+ ' DJJ--/0l+q0 
eooOF#7
 !!LLqy)9O&	 " rA   c	                 0   d}	|d   D ]
  }
|
j                   |	t        j                  |
      z  }	|j                  |
       |
j                   j                  rt        d      |j                  |
j                          | j                  |
   }t        |      dk(  r|d   s|d   r0t        j                  dt        j                  |
j                        n$t        j                  d	t        j                  
      |d<   t        j                  |
t        j                        |d<   t        j                  |
t        j                        |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        |d   t               r|d   st        d      |j                  |d           |	S )NFr   z'AdamW does not support sparse gradientsr   r   r    )rE   r*   r&   rD   rC   )memory_formatexp_avg
exp_avg_sqmax_exp_avg_sqr$   r   zB`requires_grad` is not supported for `step` in differentiable moder   r    r'   )gradr,   
is_complexappend	is_sparser:   rI   rK   zerosrO   r*   rM   
zeros_likepreserve_formatrequires_gradr6   r   )r>   rP   params_with_gradgradsr$   exp_avgsexp_avg_sqsmax_exp_avg_sqsstate_stepshas_complexr0   rI   s               r2   _init_groupzAdamW._init_groupZ   s    xAvv~5++A..K##A&vv"#LMMLL JJqME 5zQ
 \*eGn KK%--Ic? f $)#3#3U%:%:$i  ',&6&6U%:%:'l# .3.>.>)>)>/E*+ OOE),-u\23Y&&u-='>?%&5=+F+F"#ghh YJuT{F$CER^L_"#jkkuV}-] !^ rA   c                    | j                          d}|$t        j                         5   |       }ddd       | j                  D ]  }g }g }g }g }g }g }	|d   }
|d   \  }}| j	                  ||||
||||	      }t        ||||||	f|
|||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$   beta1beta2r    r#   r"   r   r   r   r   r   rk   rl   rh   ) _cuda_graph_capture_health_checkr,   enable_gradr=   ri   r   getattr)r>   closurelossrP   rb   rc   rd   re   rf   rg   r$   rm   rn   rh   s                 r2   rC   z
AdamW.step   s:    	--/""$y % &&E!EHK OKI&G >LE5** 	K    ;">2%Lz*i( .$%56Gn"4t<!$T:')+ 'X _ %$s   C		C)gMbP?)g?g+?g:0yE>g{Gz?FN)__name__
__module____qualname__r   r   rN   r   r   boolr   r9   rF   ri   r   rC   __classcell__)r@   s   @r2   r   r      s     $(%1":W "& $ $:W:W %- :W UE\"	:W
 :W :W :W :W $:W :W :W ~:WxP";z ": ":rA   a  Implements AdamW 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)},
                \: \epsilon \text{ (epsilon)}                                                    \\
            &\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} \theta_t \leftarrow \theta_{t-1} - \gamma \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 - \gamma \widehat{m_t}/
                \big(\sqrt{\widehat{v_t}^{max}} + \epsilon \big)                                 \\
            &\hspace{5mm}\textbf{else}                                                           \\
            &\hspace{10mm}\theta_t \leftarrow \theta_t - \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 `Decoupled Weight Decay Regularization`_.
    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 coefficient (default: 1e-2)
        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
    .. _Decoupled Weight Decay Regularization:
        https://arxiv.org/abs/1711.05101
    .. _On the Convergence of Adam and Beyond:
        https://openreview.net/forum?id=ryQu7f-RZ

    r   rc   rd   re   rf   rg   r   r   r   r   rk   rl   rh   r$   rm   rn   r    r#   r"   r   c                h   t         j                  j                         st        d |D              st	        d      |	)|'t        | |d      \  }}|rt        |t              r|sd}|	d}	|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)	zpFunctional API that performs AdamW algorithm computation.

    See :class:`~torch.optim.AdamW` for details.
    c              3   P   K   | ]  }t        |t        j                           y wrt   )r6   r,   r   )r.   ts     r2   r3   zadamw.<locals>.<genexpr>4  s     2dXcST:a3NXcs   $&zPAPI has changed, `state_steps` argument must contain a list of singleton tensorsNF)	use_fusedz6torch.jit.script not supported with foreach optimizersz4torch.jit.script not supported with fused optimizers)r$   rm   rn   r    r#   r"   r   r   r   rk   rl   rh   )r,   _utilsis_compilingr<   r:   r   r6   r   jitis_scripting_fused_adamw_multi_tensor_adamw_single_tensor_adamw)r   rc   rd   re   rf   rg   r   r   r   r   rk   rl   rh   r$   rm   rn   r    r#   r"   r   _funcs                         r2   r   r     s$   : <<$$&s2dXc2d/d^
 	
 }1&.TYZ
7z"f-jG}599))+STT'')QRRUYY++-	//1"#!%%rA   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       t        j                  |      rqt        j                  |      }t        j                  |      }t        j                  |      }|rt        j                  ||         ||<   t        j                  |      }|dz  }|j                  d||z  z
         |j                  |d|	z
         |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+                  ||       nt-        |      }d|	|z  z
  }d|
|z  z
  }||z  }t/        |      }|rDt        j&                  ||   |||          ||   j!                         |z  j)                  |      }n"|j!                         |z  j)                  |      }|j+                  |||        |st        j                  | |         st        j0                  ||         ||<   ! y )NzGIf capturable=True, params and state_steps must be CUDA or XLA tensors.r   )value)out)r,   r   r   r6   rN   	enumerater~   r   is_cudais_xlar[   view_as_realmul_lerp_addcmul_negsqrtclonecopy_maximumadd_addcdiv_r   r   view_as_complex) r   rc   rd   re   rf   rg   rk   rl   r$   rm   rn   r    r#   r"   r   r   r   rh   iparamrZ   rW   rX   step_trC   bias_correction1bias_correction2	step_sizestep_size_negbias_correction2_sqrtrY   denoms                                    r2   r   r   i  s^   , )"333yy "e$$$f%5'uQxeAhY1+ ^
Q ||((*z6>>u||YXYV E"%%d+D((1G++J7J%*%7%78J%K"&&u-E 	! 	

1rL(() 	dAI&''d!e)'DD 5D=0 5D=0--I%MMOM$4$9$9$;!!%4Q%7%=%=%?N%4Q%7N"((~z)RS $A&++-1F1VW$s]*+ 
 OO%)>)NO$s]*+  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k &rA   c       
   	      *   t        |       dk(  ry t        |t              r|st        d      t        j
                  j                         s%|r#t        d t        | |      D              sJ d       |rJ d       ||J t        j                  | |||||g      }|j                         D ]R  \  \  }}}}}}}|rt	        j                  |      }|r |rt        |||||       nt        ||||       |d   j                  r.t	        j                  |t	        j                   dd      d	       nt	        j                  |d
       |dk7  rt	        j"                  |d
||z  z
         t	        j$                  ||d
|	z
         t	        j"                  ||
       t	        j&                  |||d
|
z
         ~|rOt	        j(                  |	|      }t	        j(                  |
|      }t	        j*                  |d
       t	        j*                  |d
       t	        j,                  |       t	        j.                  ||       t	        j0                  |       t	        j2                  |       |}|}|r,t	        j4                  ||       t	        j6                  |      }nt	        j6                  |      }t	        j.                  ||       t	        j                  ||       t	        j.                  ||       t	        j8                  |||       Y|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]  } t?        |        }} |r,t	        j4                  ||       t	        j6                  |      }nt	        j6                  |      }t	        j.                  ||       t	        j                  ||       t	        j8                  ||||       U 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rt   )r   )r.   r0   rC   s      r2   r3   z&_multi_tensor_adamw.<locals>.<genexpr>  s)      
6N71dAII&$,,&6Ns   ')z@If capturable=True, params and state_steps must be CUDA tensors.z#_foreach ops don't support autogradr(   cpu)r*   )alphar   ) rK   r6   r   r:   r,   r~   r   r<   zipr   "_group_tensors_by_device_and_dtyperJ   _foreach_negr   is_cpu_foreach_add_rM   _foreach_mul__foreach_lerp__foreach_addcmul__foreach_pow_foreach_sub__foreach_neg__foreach_div__foreach_reciprocal__foreach_sqrt__foreach_maximum__foreach_sqrt_foreach_addcdiv_r   r	   r   )!r   rc   rd   re   rf   rg   rk   rl   r$   rm   rn   r    r#   r"   r   r   r   rh   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_sqrtrC   bcs!                                    r2   r   r     s   * 6{a"fjbcc <<$$&: 
69&+6N
 
 	NM	N 
 DDD)"333BBxo{DL MO ##%	
 
 --l;Lm\?L^`vwm\?L^_ a '' 2ELLU4S[^_ 2A6 1q23D/DE 	_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\]J\$EZ-=$= =J\]J\]J\$EZ-=$= =J\]+FV,WFVb2g^FV,WXIBR$SBRB^B%7BR!$S''(>@RS #("5"56L"M"'"5"56H"I1FG5##M?OU^_o &J  ^],W$Ss   P%PP
"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    rm   rn   r#   r"   r   rk   rl   )r:   r*   r6   r   strr   r   itemstor,   r   _fused_adamw_r   rK   ) r   rc   rd   re   rf   rg   rk   rl   r$   rm   rn   r    r#   r"   r   r   r   rh   grad_scale_dictfound_inf_dictlr_dictr   r*   r   r   r   r   r   r   r   device_grad_scaledevice_found_infs                                    r2   r   r   g  s   * VWW9C9Oz((*5UYO6?6Ki&&	2QUN ",B!7C		Ne<Sryy"oY]GBB	+LNO 4C3H3H3J	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`aA 4KrA   )NFFNNNF) r,   r   	optimizerr   r   r   r   r	   r
   r   r   r   r   r   r   r   typingr   r   r   r   torch.utils._foreach_utilsr   __all__r   __doc__rx   rN   r   r   r   r   rU   rA   r2   <module>r      s    i i i i 0 / KG
FI FR&L	 
 		 		 		 		 'M?V #  #'"&OLO<O 6lO f	O
 &\O fO d^O O O D>O  O O O" #O$ %O& 'O( 	eVm)O* +O, 
-O. /OdsKLsK<sK 6lsK f	sK
 &\sK fsK  sK sK sK sK sK 	femsK sK 
sK  !sK" #sK$ %sK& 'sKlE`LE`<E` 6lE` f	E`
 &\E` fE`  E` E` E` E` E` 	femE` E` 
E`  !E`" #E`$ %E`& 'E`P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 	eVmHb Hb 
Hb  !Hb" #Hb$ %Hb& 'Hb( 
)HbrA   