
    $hjn              )          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dS ))    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   MbP?g?g+?:0yE>{Gz?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	                                          ||           |rj|
rt          d          d| _        t                      t          fd| j
        D                       st          d d          |rt          d          d S d S )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   r   K   | ]1}|d          D ]&}|j         j        v ot          j        |          V  '2dS )r#   N)devicetypetorchis_floating_point).0pgpfused_supported_devicess      Q/var/www/html/auto_sub_bot/venv/lib/python3.11/site-packages/torch/optim/adamw.py	<genexpr>z!AdamW.__init__.<locals>.<genexpr>?   sp         R\  12 !88 +'**          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"   defaultsr5   	__class__s                @r6   r>   zAdamW.__init__   s<    byy;r;;<<<b&!! 	fg 	fj 	fdeeeczz<s<<===eAh$$$$$$$$M58MMNNNeAh$$$$$$$$M58MMNNNl""JLJJKKK%!)
 
 
 	*** 	W P"#NOOO.2D+
 'K&L&L#     +     U
 # $T9P$T $T $T U U U W"#UVVV#	W 	W W Wr8   c                    t                                          |           | j        D ]}|                    dd           |                    dd           |                    dd            |                    dd           |                    dd           |                    dd            t	          | j                                                  }t          |          dk    ot          j	        |d         d	                   }|s;|D ]:}t          j
        t          |d	                   t          j        
          |d	<   9d S d S )Nr(   Fr   r   r    r!   r"   r   stepdtype)r=   __setstate__rB   
setdefaultliststatevalueslenr0   	is_tensortensorfloatfloat32)rC   rM   groupstate_valuesstep_is_tensorsrE   s         r6   rJ   zAdamW.__setstate__I   s]   U###& 	, 	,EY...Z///Y---\5111-u555Wd++++DJ--//00l++q0 
eoOF#7
 7
  	P! P P!Lqy)9)9OOO&			P 	PP Pr8   c	                 b   d}	|d         D ]"}
|
j         |	t          j        |
          z  }	|                    |
           |
j         j        rt          d          |                    |
j                    | j        |
         }t          |          dk    r|d         s|d         r&t          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<   |                    |d                    |                    |d                    |d         r|                    |d                    |d         r|d         j        rt          d          |d         r2t          |d         t                     r|d         st          d          |                    |d                    $|	S )NFr#   z'AdamW does not support sparse gradientsr   r    r"    )rI   r.   r*   rH   rG   )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+   )gradr0   
is_complexappend	is_sparser?   rM   rO   zerosrS   r.   rQ   
zeros_likepreserve_formatrequires_gradr;   r   )rC   rT   params_with_gradgradsr(   exp_avgsexp_avg_sqsmax_exp_avg_sqsstate_stepshas_complexr4   rM   s               r6   _init_groupzAdamW._init_groupZ   sV    x .	. .	.Av~5+A...K##A&&&v N"#LMMMLL   JqME 5zzQ
 \*@.3Gn@EK%-IIIIc??? f $)#3U%:$ $ $i  ',&6U%:' ' 'l#  .3.>)>/ / /E*+ OOE),---u\2333Y @&&u-='>???%& i5=+F i"#ghhh Y lJuT{F$C$C lER^L_ l"#jkkkuV}----r8   c                    |                                   d}|5t          j                    5   |            }ddd           n# 1 swxY w Y   | j        D ]}g }g }g }g }g }g }	|d         }
|d         \  }}|                     ||||
||||	          }t          ||||||	f|
|||d         |d         |d         |d         |d         |d	         |d
         |d         t          | dd          t          | dd          |d |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"   
grad_scale	found_inf)r(   beta1beta2r$   r'   r&   r   r   r    r!   r"   ro   rp   rl   ) _cuda_graph_capture_health_checkr0   enable_gradrB   rm   r   getattr)rC   closurelossrT   rf   rg   rh   ri   rj   rk   r(   rq   rr   rl   s                 r6   rG   z
AdamW.step   s    	--///"$$ ! !wyy! ! ! ! ! ! ! ! ! ! ! ! ! ! ! & *	 *	E!EHK OKI&G >LE5** 	 	K    ;">2%Lz*i( .$%56Gn"4t<<!$T::')    . s   AA
A)r   r   r   r   FN)__name__
__module____qualname__r   r   rR   r   r   boolr   r>   rJ   rm   r   rG   __classcell__)rE   s   @r6   r   r      sX        $(%1":W "& $ $:W :W :W:W %- :W UE\"	:W
 :W :W :W :W $:W :W :W ~:W :W :W :W :W :WxP P P P P"; ; ;z ": : : "!: : : : :r8   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

    Fr#   rg   rh   ri   rj   rk   r   r    r!   r"   ro   rp   rl   r(   rq   rr   r$   r'   r&   r   c                   t           j                                        s(t          d |D                       st	          d          |	2|0t          | |d          \  }}|rt          |t                    r|sd}|	d}	|d}|r-t           j        	                                rt	          d          |	r-t           j        	                                rt	          d          |	r&t           j        	                                st          }n/|r&t           j        	                                st          }nt          } || |||||||||||||||
||           dS )	zpFunctional API that performs AdamW algorithm computation.

    See :class:`~torch.optim.AdamW` for details.
    c              3   J   K   | ]}t          |t          j                  V  d S rx   )r;   r0   r   )r2   ts     r6   r7   zadamw.<locals>.<genexpr>4  s/      2d2dST:a3N3N2d2d2d2d2d2dr8   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(   rq   rr   r$   r'   r&   r   r    r!   ro   rp   rl   )r0   _utilsis_compilingrA   r?   r   r;   r   jitis_scripting_fused_adamw_multi_tensor_adamw_single_tensor_adamw)r#   rg   rh   ri   rj   rk   r   r    r!   r"   ro   rp   rl   r(   rq   rr   r$   r'   r&   r   _funcs                         r6   r   r     s   : <$$&& 
s2d2dXc2d2d2d/d/d 
^
 
 	
 }1&.TYZZZ
7 	z"f-- 	j 	G} U59))++ USTTT S'')) SQRRR $UY++-- $	 $//11 $"#D!%%     r8   c       
            ||J t           j                                        rt          |t                    sJ t          |           D ]}\  }}|s||         n||          }||         }||         }||         }t           j                                        s(|r&|j        r|j        s|j	        r|j	        s
J d            t          j
        |          rot          j        |          }t          j        |          }t          j        |          }|rt          j        ||                   ||<   t          j        |          }|dz  }|                    d||z  z
             |                    |d|	z
             |                    |
                              ||d|
z
             |s|r|}d|	|z  z
  }d|
|z  z
  }||z  }|                                }|                                }|r|r||                                         }n||         }||                             t          j        ||                     ||                                         ||z  z                      ||z            }n0|                                ||z  z                      ||z            }|                    ||           nt-          |          }d|	|z  z
  }d|
|z  z
  }||z  }t/          |          }|rTt          j        ||         |||                    ||                                         |z                      |          }n*|                                |z                      |          }|                    |||            |r7t          j
        | |                   rt          j        ||                   ||<   d S )NzGIf capturable=True, params and state_steps must be CUDA or XLA tensors.r   )value)out)r0   r   r   r;   rR   	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#   rg   rh   ri   rj   rk   ro   rp   r(   rq   rr   r$   r'   r&   r   r    r!   rl   iparamr^   r[   r\   step_trG   bias_correction1bias_correction2	step_sizestep_size_negbias_correction2_sqrtr]   denoms                                    r6   r   r   i  s?   , )"3"33y % "e$$$$$f%% UK UK5'6uQxxeAhY1+ ^
Q |((** 	Yz 	YY#)>Y7<|YHNY YXY YV E"" 	.%d++D(11G+J77J L%*%78J%K%K"&u--E 	! 	

1rL(())) 	dAI&&&''d!e)'DDD 3	= 3	=D 5D=0 5D=0--I%MMOOM$4$9$9$;$;! ,! 8%4Q%7%=%=%?%?NN%4Q%7N"((~z)R)RSSS $A&++--1F1VW$s]*++ 
 OO%%)>)NO$s]*++  NN7E****f%%D 5D=0 5D=0--I$23C$D$D! Noa0*/RSBTUUUU )+00225JJPPQTUU#**-BBHHMMNN7E)N<<<  	Ku'q	22 	K!&!6q7I!J!JOAkUK UKr8   c       
           	
 t          |           dk    rd S t          t                    r|st          d          t          j                                        s3|r1t          d t          | |          D                       s
J d            |r
J d            ||J t          j
        | |||||g          }|                                D ]\  \  }}}}}}}|rt	          j        |          }|r(|rt          |||||           nt          ||||           |d         j        r,t	          j        |t	          j        dd          d	           nt	          j        |d
           |dk    rt	          j        |d
|z  z
             t	          j        ||d
	z
             t	          j        |
           t	          j        |||d

z
             ~|r@t	          j        	|          }t	          j        
|          }t	          j        |d
           t	          j        |d
           t	          j        |           t	          j        |           t	          j        |           t	          j        |           |}|}|r*t	          j        ||           t	          j        |          }nt	          j        |          }t	          j        ||           t	          j        ||           t	          j        ||           t	          j        |||           H	fd|D             }
fd|D             }t;          fd|D                       }d |D             }|r*t	          j        ||           t	          j        |          }nt	          j        |          }t	          j        ||           t	          j        ||           t	          j        ||||           d S )Nr   r+   c              3   8   K   | ]\  }}|j         o|j         V  d S rx   )r   )r2   r4   rG   s      r6   r7   z&_multi_tensor_adamw.<locals>.<genexpr>  s@       
 
+21dAI&$,
 
 
 
 
 
r8   z@If capturable=True, params and state_steps must be CUDA tensors.z#_foreach ops don't support autogradr,   cpu)r.   )alphar   c                 :    g | ]}d t          |          z  z
  S r   r   )r2   rG   rq   s     r6   
<listcomp>z'_multi_tensor_adamw.<locals>.<listcomp>R  +    ]]]$EZ-=-=$= =]]]r8   c                 :    g | ]}d t          |          z  z
  S r   r   )r2   rG   rr   s     r6   r   z'_multi_tensor_adamw.<locals>.<listcomp>S  r   r8   c                      g | ]
}|z  d z  S )rY   )r2   bcr$   s     r6   r   z'_multi_tensor_adamw.<locals>.<listcomp>U  s!    ,W,W,Wb2g^,W,W,Wr8   c                 ,    g | ]}t          |          S rY   )r   )r2   r   s     r6   r   z'_multi_tensor_adamw.<locals>.<listcomp>W  s     $S$S$SB^B%7%7$S$S$Sr8   )rO   r;   r   r?   r0   r   r   rA   zipr   "_group_tensors_by_device_and_dtyperN   _foreach_negr   is_cpu_foreach_add_rQ   _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#   rg   rh   ri   rj   rk   ro   rp   r(   rq   rr   r$   r'   r&   r   r    r!   rl   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_sqrts            ```                   r6   r   r     s   * 6{{a"f dj dbccc <$$&& N: N 
 
69&+6N6N
 
 
 
 
 	N 	NM	N 	N 
 DDDDD)"3"33Bxo{DL M MO ##%%^` ^` 	
 
 	< -l;;L 	` `m\?L^`vwwwwm\?L^___ a ' 	7 2ELU4S4S4S[^_____ 2A666 1q23D/DEEE 	_lAIFFF.666 2L,PQTYPYZZZ  7	`$1%9KLL$1%9KLL 0!444 0!444 0111  0"555&'7888 !1222
 )I$4! J'(>@RSSS #("56L"M"M"'"56H"I"I1FGGG555;;; #M?OTTTT]]]]J\]]]]]]]J\]]]+,W,W,W,WFV,W,W,WXXI$S$SBR$S$S$S! J'(>@RSSS #("56L"M"M"'"56H"I"I1FGGG555#M?OU^____}^` ^`r8   returnc       
            | sd S |rt          d          |	|j        |ind }|	|j        |ind }t          |t                    r!t	          |j                  dk    r	|j        |ind }t          j        | |||||g          }|                                D ]\  \  }}\  \  }}}}}}}d\  }}|&||vr|                    |d          ||<   ||         }|&||vr|                    |d          ||<   ||         }|&||vr"|                    |d          ||<   ||         }t          j
        |d           t          j        |||||||||	|
|||||           |&t          j        ||gt          |          z             d S )	Nz9Adam with fused=True does not support differentiable=Truer   )NNT)non_blocking)r.   r   r   )	r(   r$   rq   rr   r'   r&   r   ro   rp   )r?   r.   r;   r   strr   r   itemstor0   r   _fused_adamw_r   rO   ) r#   rg   rh   ri   rj   rk   ro   rp   r(   rq   rr   r$   r'   r&   r   r    r!   rl   grad_scale_dictfound_inf_dictlr_dictr   r.   r   r   r   r   r   r   r   device_grad_scaledevice_found_infs                                    r6   r   r   g  s7   *   XVWWW9C9Oz(*55UYO6?6Ki&	22QUN ",B!7!7]C	NNe<S<Sry"ooY]GB	+LN NO 4C3H3H3J3J%b %b 	0 0 ,}#&)-)Q.8++!_,,*4--T-*R*R' / 7 ..)2f4)P)Pv&-f56#8#8 ee6eEEGFOB.222"%(&	
 	
 	
 	
" ' 25E4FM_I`I`4`aaaK%b %br8   )NFFNNNF) r0   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__r|   rR   r   r   r   r   rY   r8   r6   <module>r      s]         i i i i i i i i i i i i i i i i i i i i i i i i i i i i i i 0 / / / / / / / / / / / K K K K K KG
F F F F FI F F FR&L 
   
! " 
# $ 
% & 
'  M?V #  #'"&O 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 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 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` 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 Hb Hb Hb Hb Hbr8   