




'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowercase      :   Any      =       {"""configuration_xlnet""": ["""XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP""", """XLNetConfig"""]}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase      :   Optional[Any]      =       ["""XLNetTokenizer"""]

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase      :   Tuple      =       ["""XLNetTokenizerFast"""]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase      :   Union[str, Any]      =       [
          """XLNET_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """XLNetForMultipleChoice""",
          """XLNetForQuestionAnswering""",
          """XLNetForQuestionAnsweringSimple""",
          """XLNetForSequenceClassification""",
          """XLNetForTokenClassification""",
          """XLNetLMHeadModel""",
          """XLNetModel""",
          """XLNetPreTrainedModel""",
          """load_tf_weights_in_xlnet""",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase      :   Any      =       [
          """TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """TFXLNetForMultipleChoice""",
          """TFXLNetForQuestionAnsweringSimple""",
          """TFXLNetForSequenceClassification""",
          """TFXLNetForTokenClassification""",
          """TFXLNetLMHeadModel""",
          """TFXLNetMainLayer""",
          """TFXLNetModel""",
          """TFXLNetPreTrainedModel""",
      ]


if TYPE_CHECKING:
      from .configuration_xlnet import XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP, XLNetConfig

      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_xlnet import XLNetTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_xlnet_fast import XLNetTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_xlnet import (
                XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
                XLNetForMultipleChoice,
                XLNetForQuestionAnswering,
                XLNetForQuestionAnsweringSimple,
                XLNetForSequenceClassification,
                XLNetForTokenClassification,
                XLNetLMHeadModel,
                XLNetModel,
                XLNetPreTrainedModel,
                load_tf_weights_in_xlnet,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_xlnet import (
                TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFXLNetForMultipleChoice,
                TFXLNetForQuestionAnsweringSimple,
                TFXLNetForSequenceClassification,
                TFXLNetForTokenClassification,
                TFXLNetLMHeadModel,
                TFXLNetMainLayer,
                TFXLNetModel,
                TFXLNetPreTrainedModel,
            )

else:
      import sys

      lowercase      :   Union[str, Any]      =       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)









'''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							)



