




# This test is meant to be run in on an instance with TPUs like this:
#
#   python examples/pytorch/xla_spawn.py --num_cores=8 tests/test_trainer_tpu.py
#
# Replace 8 with the number of TPU cores you have.
#

import sys
from typing import Dict

from transformers import EvalPrediction, HfArgumentParser, TrainingArguments, is_torch_available
from transformers.utils import logging


snake_case_					:					Tuple       						=			logging.get_logger(__name__)


if is_torch_available():
    import torch
    from torch import nn
    from torch.utils.data import Dataset

    from transformers import Trainer







    class __snake_case     (     SCREAMING_SNAKE_CASE__						):







       def __init__( self						:		List[str]   ,		_snake_case						:		int = 101):

            """simple docstring"""


            UpperCAmelCase_		=				length







       def __len__( self						:		Optional[int]):

            """simple docstring"""


            return self.length







       def __getitem__( self						:		List[str]   ,		_snake_case						:		str):

            """simple docstring"""


            return i







    class __snake_case     :







       def __call__( self						:		List[str]   ,		_snake_case						:		Union[str, Any]):

            """simple docstring"""


            return {"input_ids": torch.tensor(lowerCAmelCase_), "labels": torch.tensor(lowerCAmelCase_)}







    class __snake_case     (     nn.Module						):







       def __init__( self						:		Union[str, Any]):

            """simple docstring"""


            super().__init__()
            # Add some (unused) params otherwise DDP will complain.
            UpperCAmelCase_		=				nn.Linear(120   ,		80)







       def lowerCamelCase		( self						:		Dict   ,		_snake_case						:		Optional[Any]   ,		_snake_case						:		Union[str, Any]=None):

            """simple docstring"""


            if labels is not None:
                 return torch.tensor(0.0   ,		device=input_ids.device), input_ids
            else:
                 return input_ids


def   A		()  -> Dict:







     """simple docstring"""


     UpperCAmelCase_		=				HfArgumentParser((TrainingArguments,)			)
     sys.argv += ["--output_dir", "./examples"]
     UpperCAmelCase_		=				parser.parse_args_into_dataclasses()[0]

     logger.warning(
         F"""Process rank: {training_args.local_rank}, device: {training_args.device}, """
         F"""tpu_num_cores: {training_args.tpu_num_cores}"""  ,							)

     # Essentially, what we want to verify in the distributed case is
     # that we get all samples back, in the right order.
     # (this is crucial for prediction for instance)
     for dataset_length in [1001, 256, 15]:
          UpperCAmelCase_		=				DummyDataset(__A			)

          def compute_metrics(__A  :       Optional[Any]			) -> Dict:
               UpperCAmelCase_		=				list(range(len(__A			)			)			)
               UpperCAmelCase_		=				p.predictions.tolist() == sequential and p.label_ids.tolist() == sequential
               return {"success": success}

          UpperCAmelCase_		=				Trainer(
              model=DummyModel()  ,							args=__A  ,							data_collator=DummyDataCollator()  ,							eval_dataset=__A  ,							compute_metrics=__A  ,							)
          UpperCAmelCase_		=				trainer.evaluate()
          logger.info(__A			)
          if metrics["eval_success"] is not True:
               logger.error(__A			)
               exit(1			)

          UpperCAmelCase_		=				trainer.predict(__A			)
          logger.info(p.metrics			)
          if p.metrics["test_success"] is not True:
               logger.error(p.metrics			)
               exit(1			)

          UpperCAmelCase_		=				2

          UpperCAmelCase_		=				trainer.evaluate()
          logger.info(__A			)
          if metrics["eval_success"] is not True:
               logger.error(__A			)
               exit(1			)

          UpperCAmelCase_		=				trainer.predict(__A			)
          logger.info(p.metrics			)
          if p.metrics["test_success"] is not True:
               logger.error(p.metrics			)
               exit(1			)

          UpperCAmelCase_		=				None

     logger.info('''🔥 All distributed tests successful'''			)


def   A		(__A  :       str			)  -> Optional[Any]:







     """simple docstring"""


     main()


if __name__ == "__main__":
    main()








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase__						:	Any	     = {
    'configuration_decision_transformer': [
        'DECISION_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'DecisionTransformerConfig',
    ],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase__						:	Optional[Any]	     = [
       'DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
       'DecisionTransformerGPT2Model',
       'DecisionTransformerGPT2PreTrainedModel',
       'DecisionTransformerModel',
       'DecisionTransformerPreTrainedModel',
   ]


if TYPE_CHECKING:
   from .configuration_decision_transformer import (
       DECISION_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
       DecisionTransformerConfig,
   )

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_decision_transformer import (
          DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          DecisionTransformerGPTaModel,
          DecisionTransformerGPTaPreTrainedModel,
          DecisionTransformerModel,
          DecisionTransformerPreTrainedModel,
      )


else:
   import sys

   UpperCAmelCase__						:	Optional[Any]	     = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



