






from ...configuration_utils import PretrainedConfig
from ...utils import logging


SCREAMING_SNAKE_CASE__		:							Tuple 				=				logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__		:							List[Any] 				=				{
    """MIT/ast-finetuned-audioset-10-10-0.4593""": (
        """https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json"""
    ),
}







class 				UpperCAmelCase_  (		__lowerCamelCase		):
     __lowerCamelCase      				=  'audio-spectrogram-transformer'




     def __init__(				self	,						_lowerCAmelCase=768	,						_lowerCAmelCase=12	,						_lowerCAmelCase=12	,						_lowerCAmelCase=3072	,						_lowerCAmelCase="gelu"	,						_lowerCAmelCase=0.0	,						_lowerCAmelCase=0.0	,						_lowerCAmelCase=0.0_2	,						_lowerCAmelCase=1e-12	,						_lowerCAmelCase=16	,						_lowerCAmelCase=True	,						_lowerCAmelCase=10	,						_lowerCAmelCase=10	,						_lowerCAmelCase=1024	,						_lowerCAmelCase=128	,						**_lowerCAmelCase	,						):
          super().__init__(**_lowerCAmelCase		)

          UpperCAmelCase__      :  Optional[int]				      =			hidden_size
          UpperCAmelCase__      :  int				      =			num_hidden_layers
          UpperCAmelCase__      :  List[Any]				      =			num_attention_heads
          UpperCAmelCase__      :  Dict				      =			intermediate_size
          UpperCAmelCase__      :  Dict				      =			hidden_act
          UpperCAmelCase__      :  str				      =			hidden_dropout_prob
          UpperCAmelCase__      :  str				      =			attention_probs_dropout_prob
          UpperCAmelCase__      :  Tuple				      =			initializer_range
          UpperCAmelCase__      :  Dict				      =			layer_norm_eps
          UpperCAmelCase__      :  Optional[Any]				      =			patch_size
          UpperCAmelCase__      :  Tuple				      =			qkv_bias
          UpperCAmelCase__      :  Tuple				      =			frequency_stride
          UpperCAmelCase__      :  Union[str, Any]				      =			time_stride
          UpperCAmelCase__      :  Optional[Any]				      =			max_length
          UpperCAmelCase__      :  Optional[int]				      =			num_mel_bins












'''simple docstring'''







# We ignore warnings about stepping the scheduler since we step it ourselves during gradient accumulation

import warnings

from .state import AcceleratorState, GradientState


warnings.filterwarnings("""ignore""", category=UserWarning, module="""torch.optim.lr_scheduler""")







class 					_a :





     '''simple docstring'''



     def __init__(				self							,__a							,__a							,__a = True							,__a = False							)      ->				Dict:
          snake_case			:      List[Any]        =			scheduler
          snake_case			:      List[Any]        =			optimizers if isinstance(__a							,(list, tuple)							) else [optimizers]
          snake_case			:      List[str]        =			split_batches
          snake_case			:      List[str]        =			step_with_optimizer
          snake_case			:      int        =			GradientState()







     def 			snake_case_      (				self							,*__a							,**__a							)      ->				Optional[Any]:
          if not self.step_with_optimizer:
               # No link between scheduler and optimizer -> just step
               self.scheduler.step(*__a							,**__a							)
               return

          # Otherwise, first make sure the optimizer was stepped.
          if not self.gradient_state.sync_gradients:
               if self.gradient_state.adjust_scheduler:
                    self.scheduler._step_count += 1
               return

          for opt in self.optimizers:
               if opt.step_was_skipped:
                    return
          if self.split_batches:
               # Split batches -> the training dataloader batch size is not changed so one step per training step
               self.scheduler.step(*__a							,**__a							)
          else:
               # Otherwise the training dataloader batch size was multiplied by `num_processes`, so we need to do
               # num_processes steps per training step
               snake_case			:      List[str]        =			AcceleratorState().num_processes
               for _ in range(__a							):
                    # Special case when using OneCycle and `drop_last` was not used
                    if hasattr(self.scheduler							,"""total_steps"""							):
                         if self.scheduler._step_count <= self.scheduler.total_steps:
                              self.scheduler.step(*__a							,**__a							)
                    else:
                         self.scheduler.step(*__a							,**__a							)







     def 			snake_case_      (				self							)      ->				Dict:
          return self.scheduler.get_last_lr()







     def 			snake_case_      (				self							)      ->				int:
          return self.scheduler.state_dict()







     def 			snake_case_      (				self							,__a							)      ->				Any:
          self.scheduler.load_state_dict(__a							)







     def 			snake_case_      (				self							)      ->				Any:
          return self.scheduler.get_lr()







     def 			snake_case_      (				self							,*__a							,**__a							)      ->				Optional[Any]:
          return self.scheduler.print_lr(*__a							,**__a							)



