+
    &jY              
           ^ RI Ht ^ RIt^ RIHt ^RIHtHtHtHtH	t	H
t
HtHtHtHtHtHtHtHt RR.t ! R R]4      tRR	] R
] R] R] R2	,           ]n        RR R lltR tR R ltR R ltR R ltR# )    )castN)Tensor)_default_to_fused_or_foreach_device_dtype_check_for_fused_differentiable_doc_foreach_doc_get_scalar_dtype
_get_value_maximize_doc_params_doc
_to_scalar_use_grad_for_differentiable_view_as_real
DeviceDict	OptimizerParamsTAdagradadagradc                      a a ] tR t^t oRRRRRRR/V3R lV 3R lllltV 3R ltV3R	 lR
 ltR t]RR l4       t	Rt
VtV ;t# )r   NmaximizeFdifferentiablefusedc                   < V ^8  d   QhRS[ RS[S[,          RS[RS[RS[RS[RS[R,          R	S[R
S[RS[R,          RR/# )   paramslrlr_decayweight_decayinitial_accumulator_valueepsforeachNr   r   r   return)r   floatr   bool)format__classdict__s   "k/Users/jameslopez/projects/CWCArchive/cwc-podcast/.venv/lib/python3.14/site-packages/torch/optim/adagrad.py__annotate__Adagrad.__annotate__   s     E EE FNE 	E
 E $)E E E E E d{E 
E    c                 < \        V\        4      '       d!   VP                  4       ^8w  d   \        R4      hRV8:  g   \        RV 24      hRV8:  g   \        RV 24      hRV8:  g   \        RV 24      hRV8:  g   \        RV 24      hRV8:  g   \        RV 24      hRVR	VR
VRVRVRVRVRV	RV
/	p\        SV `  W4       V
'       d5   V	'       d   \        R4      hV'       d   \        R4      hRV n        RV n        V P                   F  pVR,           F  pV P                  V,          pVR,          '       d5   \        P                  ! R\        VR,          R7      VP                  R7      M\        P                  ! R\        4       R7      VR&   \        P                   ! V4      '       d   \#        WU4      MTp\        P$                  ! W\        P&                  R7      VR&   K  	  K  	  R# )   zTensor lr must be 1-element        zInvalid learning rate: zInvalid lr_decay value: zInvalid weight_decay value: z)Invalid initial_accumulator_value value: zInvalid epsilon value: r   r   r    r   r   r!   r   r   r   z)`fused` does not support `differentiable`z0`fused` and `foreach` cannot be `True` together.Tr   is_fuseddtypedevicer1   stepmemory_formatsumN )
isinstancer   numel
ValueErrorsuper__init__RuntimeError"_need_device_dtype_check_for_fused_step_supports_amp_scalingparam_groupsstatetorchzerosr	   r2   tensor
is_complexcomplex	full_likepreserve_format)selfr   r   r   r   r   r    r!   r   r   r   defaultsgroupprB   
init_value	__class__s   &&&&&&&&$$$     r'   r=   Adagrad.__init__   s    b&!!bhhjAo:;;by6rd;<<h7zBCCl";L>JKK//;<U;VW  cz6se<== "3L')BwnU

 	*"#NOO"#UVV6:D3.2D+&&E8__

1 W~~ KK/wH xx c1B1DE f ''** 5Q2 
  %1F1F e! % 'r*   c           	       < \         S
V `  V4       R pV P                   EF   pVP                  RR 4       VP                  RR4       VP                  RR4       VP                  RR 4      pVR,           F  pV P                  P                  V. 4      p\        V4      ^ 8w  g   K1  \        P                  ! VR,          4      '       d   KV  \        VR,          4      pVR,          '       d.   \        P                  ! V\        VR7      VP                  R	7      M\        P                  ! V\        4       R
7      VR&   K  	  EK#  	  \        V P                  P                  4       4      p\        V4      ^ 8g  ;'       d%    \        P                  ! V^ ,          R,          4      pV'       gA   V F8  p	\        P                  ! \        V	R,          4      \        VR7      R
7      V	R&   K:  	  R # R # )Nr!   r   Fr   r   r   r4   r.   r0   r3   )r<   __setstate__rA   
setdefaultrB   getlenrC   	is_tensorr#   rE   r	   r2   listvalues)rJ   rB   r   rL   rM   p_statestep_valstate_valuesstep_is_tensorsrO   s   &&        r'   rR   Adagrad.__setstate__d   s   U# &&EY-Z/-u5$$Wd3E8__**..B/w<1$U__WV_-M-M$WV_5H !>> $"3U"C#$88 #\\(:K:MN FO	 % '( DJJ--/0l+q0 
 
eooOF#7
 !!LL!F)$,=u,M&	 " r*   c                   < V ^8  d   QhRR/# )r   r"   Nr8   )r%   r&   s   "r'   r(   r)      s     - -d -r*   c                    V P                    F=  pVR,           F-  pV P                  V,          pVR,          P                  4        K/  	  K?  	  R# )z6Calls tensor.share_memory_() on the state sum tensors.r   r7   N)rA   rB   share_memory_)rJ   rL   rM   rB   s   &   r'   share_memoryAdagrad.share_memory   s?    &&E8__

1e**, % 'r*   c                   R R rvVR,           EF  pVP                   f   K  VR,          '       d&   \        V RR4      '       d   \        V4       R V n        WhP                   P                  ,          pV\
        P                  ! V4      ,          pVP                  V4       VP                  VP                   4       V P                  V,          p	\        V	4      ^ 8X  d   VR,          '       d   \        V4       VR,          '       d5   \
        P                  ! R\        VR,          R7      VP                  R7      M\
        P                  ! R\        4       R7      V	R	&   V P                  R
,          p
\
        P                  ! V4      '       d   \        W4      MT
p\
        P                   ! W\
        P"                  R7      V	R&   VP                  V	R,          4       VP                  V	R	,          4       EK  	  Wg3# )Fr   r   r?   Tr.   r0   r-   r3   r4   r   r5   r7   r8   )gradgetattrr   r?   	is_sparserC   rF   appendrB   rU   rD   r	   r2   rE   rK   rG   rH   rI   )rJ   rL   params_with_gradgrads
state_sumsstate_stepshas_sparse_gradhas_complexrM   rB   r   rN   s   &&&&&&      r'   _init_groupAdagrad._init_group   s   ',exAvv!>>g8' '
 2!4>CD;66#3#33u//22 ''*QVV$

1u:?W~~5a8 !>> "3U7^"L#$88 #\\#5F5HI &M 1531-
 !++A..   9U6 
 $)??U5J5J$E%L !!%,/""5=1Q !T ++r*   c                   RpVe.   \         P                  ! 4       ;_uu_ 4        V! 4       pRRR4       V P                   F  p. p. p. p. pV P                  W4WVV4      w  r\	        VVVVVR,          VR,          VR,          VR,          VVR,          VR,          VR,          V	VR	,          \        V R
R4      \        V RR4      R7       K  	  V#   + '       g   i     L; i)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   
grad_scale	found_inf)r   r   r   r    rm   r!   r   r   rn   r   rr   rs   )rC   enable_gradrA   ro   r   rf   )
rJ   closurelossrL   ri   rj   rk   rl   rm   rn   s
   &&        r'   r4   Adagrad.step   s     ""$$y % &&E-/"$E')J(*K+/+;+;K,(O  ;">2z*%L /i(z*$%56'Gn"4t<!$T:! ': A %$s   CC	)r?   r@   )g{Gz?r   r   r   g|=NN)__name__
__module____qualname____firstlineno__r=   rR   rb   ro   r   r4   __static_attributes____classdictcell____classcell__)rO   r&   s   @@r'   r   r      sb     E E  %E "E EN!F- -,,\ "* "* *r*   a[  Implements Adagrad algorithm.

    .. math::
       \begin{aligned}
            &\rule{110mm}{0.4pt}                                                                 \\
            &\textbf{input}      : \gamma \text{ (lr)}, \: \theta_0 \text{ (params)}, \: f(\theta)
                \text{ (objective)}, \: \lambda \text{ (weight decay)},                          \\
            &\hspace{12mm}    \tau \text{ (initial accumulator value)}, \: \eta\text{ (lr decay)}\\
            &\textbf{initialize} :  state\_sum_0 \leftarrow \tau                          \\[-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} \tilde{\gamma}    \leftarrow \gamma / (1 +(t-1) \eta)                  \\
            &\hspace{5mm} \textbf{if} \: \lambda \neq 0                                          \\
            &\hspace{10mm} g_t \leftarrow g_t + \lambda \theta_{t-1}                             \\
            &\hspace{5mm}state\_sum_t  \leftarrow  state\_sum_{t-1} + g^2_t                      \\
            &\hspace{5mm}\theta_t \leftarrow
                \theta_{t-1}- \tilde{\gamma} \frac{g_t}{\sqrt{state\_sum_t}+\epsilon}            \\
            &\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 `Adaptive Subgradient Methods for Online Learning
    and Stochastic Optimization`_.
    z
    Args:
        a  
        lr (float, Tensor, optional): learning rate (default: 1e-2)
        lr_decay (float, optional): learning rate decay (default: 0)
        weight_decay (float, optional): weight decay (L2 penalty) (default: 0)
        initial_accumulator_value (float, optional): initial value of the
            sum of squares of gradients (default: 0)
        eps (float, optional): term added to the denominator to improve
            numerical stability (default: 1e-10)
        z	
        a  
        fused (bool, optional): whether the fused implementation (CPU and CUDA only) is used.
            Currently, `torch.float64`, `torch.float32`, `torch.float16`, and `torch.bfloat16`
            are supported. (default: None). Please note that the fused implementations does not
            support sparse or complex gradients.
    .. _Adaptive Subgradient Methods for Online Learning and Stochastic
        Optimization: http://jmlr.org/papers/v12/duchi11a.html

    c          "      l   V ^8  d   QhR\         \        ,          R\         \        ,          R\         \        ,          R\         \        ,          R\        R,          R\        R,          R\        R,          R	\        R
\        R,          R\        R\        R\        R\        R\        R\        R\        RR/# )r   r   rj   rk   rl   r   Nrr   rs   rm   r!   r   rn   r   r   r   r    r   r"   )rW   r   r$   r#   )r%   s   "r'   r(   r(     s     G GLG<G VG f	G
 $;G G }G G D[G G G 	G  !G" #G$ 
%G& 'G( 
)Gr*   c                  \         ;QJ d    R V 4       F  '       d   K   RM	  RM! R V 4       4      '       g   \        R4      hVf   Vf   \        W	RR7      w  ppVf   RpVf   RpV'       d0   \        P                  P                  4       '       d   \        R4      hV'       d0   \        P                  P                  4       '       d   \        R4      hV'       d,   \        P                  P                  4       '       g   \        pM9V'       d,   \        P                  P                  4       '       g   \        pM\        pV! V VVVVVVVVVV	V
VVR	7       R# )
zlFunctional API that performs Adagrad algorithm computation.

See :class:`~torch.optim.Adagrad` for details.
c              3   V   "   T F  p\        V\        P                  4      x  K!  	  R # 5irx   )r9   rC   r   ).0ts   & r'   	<genexpr>adagrad.<locals>.<genexpr>6  s     @Kqz!U\\**Ks   ')FTzPAPI has changed, `state_steps` argument must contain a list of singleton tensorsN)	use_fusedz6torch.jit.script not supported with foreach optimizersz4torch.jit.script not supported with fused optimizers
r   r   r   r    rm   r   r   rn   rr   rs   )	allr>   r   rC   jitis_scripting_fused_adagrad_multi_tensor_adagrad_single_tensor_adagrad)r   rj   rk   rl   r   rr   rs   rm   r!   r   rn   r   r   r   r    r   _funcs   &&&&&&&&&&&$$$$$  r'   r   r     s   2 3@K@333@K@@@^
 	
 }1e

7 }599))++STT''))QRRUYY++--	//11$%!'%r*   c                 P    V P                  4       p\        P                  ! WV4      # rx   )sizerC   sparse_coo_tensor)re   grad_indicesrX   r   s   &&& r'   _make_sparser   g  s     99;D""<>>r*   c                8   V ^8  d   QhR\         \        ,          R\         \        ,          R\         \        ,          R\         \        ,          R\        R,          R\        R,          R\        R	\        R
\        R\        R\        R\        R\        R\        RR/# r   r   rj   rk   rl   rr   Nrs   r   r   r   r    rm   r   r   rn   r"   rW   r   r#   r$   )r%   s   "r'   r(   r(   l  s     A= A=LA=<A= VA= f	A=
 A= }A= 	A= A= A= 
A= A= A= A= A=  
!A=r*   c          
      N   Vf   Ve   \        R4      h\        P                  P                  4       '       g   \	        V4      p\        WW#RR7       EFO  w  rppV^,          p\        V4      pV'       g   TMV) pV^ 8w  d0   VP                  '       d   \        R4      hVP                  WR7      pV^V^,
          V,          ,           ,          pVP                  '       d   VP                  4       pVP                  4       pVP                  4       pVP                  \        VVVP                  ^4      4      4       VP!                  V4      pVP                  4       P#                  4       P                  V	4      pVP                  \        VVVV,          4      V) R7       EKQ  \        P$                  ! V4      pV'       dC   \        P&                  ! V4      p\        P&                  ! V4      p\        P&                  ! V4      pVP)                  W^R7       V'       d   VP+                  4       V	,           pMVP+                  4       P                  V	4      pVP-                  VVV) R7       V'       g   EK#  \        P.                  ! V4      p\        P.                  ! V4      pEKR  	  R # )N,Expected grad_scale and found_inf to be NoneT)strictz;weight_decay option is not compatible with sparse gradientsalphavalue)AssertionErrorrC   r   r   r   zipr
   rg   r>   addcoalesce_indices_valuesadd_r   powsparse_masksqrt_rF   view_as_realaddcmul_sqrtaddcdiv_view_as_complex)r   rj   rk   rl   rr   rs   r   r   r   r    rm   r   r   rn   paramre   	state_sumstep_tr4   clrr   grad_valuesstd
std_valuesrF   s   &&&&&&$$$$$$$$           r'   r   r   l  s    " !6KLL99!!##^*-zt+ +&Y 	!&!#t$1~~~"Q  88E86DAX--.>>>==?D==?L,,.KNN<lKOOA<NOP''-C,,.33C8JJJT<z1IJSVRV   ))%0J))$/!..y9	**51t3nn&,nn&++C0NN4SDN1z--e4!11)<	U+r*   c                8   V ^8  d   QhR\         \        ,          R\         \        ,          R\         \        ,          R\         \        ,          R\        R,          R\        R,          R\        R	\        R
\        R\        R\        R\        R\        R\        RR/# r   r   )r%   s   "r'   r(   r(     s     l? l?Ll?<l? Vl? f	l?
 l? }l? 	l? l? l? 
l? l? l? l? l?  
!l?r*   c                @   V'       d   \        R 4      hVf   Ve   \        R4      h\        V 4      ^ 8X  d   R# \        V4      p\        P                  ! WW#.4      pVP                  4        EF  w  w  ppppp\        \        \        ,          V4      p\        \        \        ,          V4      p\        \        \        ,          V4      p\        \        \        ,          V4      pT
;'       d5    \        ;QJ d    R V 4       F  '       g   K   RM	  RM! R V 4       4      pV'       d   \        VVVVVVVV	RVVVVVR7       K  V'       d   \        VVV4       V'       d   \        P                  ! V4      p\        P                  P                  4       '       gJ   V^ ,          P                   '       d1   \        P"                  ! V\        P$                  ! RRR	7      RR
7       M\        P"                  ! V^4       V^ 8w  d<   V'       d   \        P"                  ! VVVR
7       M\        P&                  ! VVVR
7      pV Uu. uF+  pV) ^\)        V4      ^,
          V,          ,           ,          NK-  	  pp\        P*                  ! VVV^R7       \        P,                  ! V4      p\        P"                  ! VV	4       V^ 8w  g	   V'       d   \        P.                  ! VV4       TpM\        P0                  ! VV4      p\        P2                  ! VVV4       EK  	  R# u upi )z#_foreach ops don't support autogradNr   c              3   8   "   T F  qP                   x  K  	  R # 5irx   )rg   )r   re   s   & r'   r   (_multi_tensor_adagrad.<locals>.<genexpr>  s      9
'3tNN|s   TFr   g      ?cpu)r2   r   r   )r   rU   r   r   "_group_tensors_by_device_and_dtyperX   r   rW   r   anyr   r   rC   _foreach_negcompileris_compilingis_cpu_foreach_add_rE   _foreach_addr
   _foreach_addcmul__foreach_sqrt_foreach_mul__foreach_mul_foreach_addcdiv_)r   rj   rk   rl   rr   rs   r   r   r   r    rm   r   r   rn   grouped_tensorlistsdevice_params_device_grads_device_state_sums_device_state_steps_r   device_paramsdevice_gradsdevice_state_sumsdevice_state_stepsdevice_has_sparse_gradr4   	minus_clrr   	numerators   &&&&&&$$$$$$$$               r'   r   r     s   " BCC!6KLL 6{a	BB#FF	
0  &&(		 	T&\>:DL-8 f/AB!$v,0CD!0 "
 "
SS 9
'39
SSS 9
'39
 6
 ""!")! $!-'%#   -7HI --l;L ~~**,,1CA1F1M1M1M"ELLU$C3  2A61##L-|T$11 -| 
 GY
FXdRC1
4(1,8899FX 	 
 	 1<UVW!!"34C%1i8$I**<CIy#>Q )p
s   1Lc                N   V ^8  d   QhR\         \        ,          R\         \        ,          R\         \        ,          R\         \        ,          R\        R,          R\        R,          R\        \        ,          R	\        R
\        R\        R\        R\        R\        R\        RR/# r   r   )r%   s   "r'   r(   r(     s     S SLS<S VS f	S
 S }S 	S S S 
S S S S S  
!Sr*   c                b   V '       g   R # V
'       g	   V'       d   \        R4      hV'       d   \        R4      hVe   VP                  V/M/ pVe   VP                  V/M/ p\        V\        4      '       d)   \	        VP                  4      R8w  d   VP                  V/MR p\
        P                  ! WW#.4      pVP                  4        EFa  w  w  ppw  w  ppppp\        \        \        ,          V4      p\        \        \        ,          V4      p\        \        \        ,          V4      p\        \        \        ,          V4      pR R ppVe$   VP                  VVP                  VRR7      4      pVe$   VP                  VVP                  VRR7      4      pVe'   VV9  d    VP                  VRR7      VV&   VV,          p\        P                  ! V^4       \        P                  ! VVVVVVVV	VVVR7       Vf   EK9  \        P                  ! VV.\!        V4      ,          4       EKd  	  R # )Nz5`fused` does not support sparse grad or complex paramz<adagrad with fused=True does not support differentiable=Truer   T)non_blocking)r2   r   )r   r   r   r    r   rr   rs   )r>   r2   r9   r   strr   r   itemsr   rW   rS   torC   r   _fused_adagrad__foreach_sub_rU   )r   rj   rk   rl   rr   rs   r   r   r   r    rm   r   r   rn   grad_scale_dictfound_inf_dictlr_dictgrouped_tensorsr2   r   r   r   r   r   r   r   r   r   device_grad_scaledevice_found_infs   &&&&&&$$$$$$$$                r'   r   r     s#   " +RSSJ
 	

 ,6+A		J'r  *3)>		9%B  &b&11c"))n6MBSW   BB	
0O 
			 	 	
	T&\>:DL-8 f/AB!$v,0CD.2D+! / : :
f4@!  -88	V$?  6#8 ee6eEGFOB.2%(&	
 '"%5$6=O9P$PC 
!r*   )NNNFNFF)typingr   rC   r   	optimizerr   r   r   r   r	   r
   r   r   r   r   r   r   r   r   __all__r   __doc__r   r   r   r   r   r8   r*   r'   <module>r      s         $ i
 Ki K^4		 	 
 		 		 5. fGT?
A=Hl?^Sr*   