






'''simple docstring'''





# 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


__A				:				Any					=		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 					lowercase							(				_lowerCamelCase   ):


     '''simple docstring'''

     def __init__(       self  :  List[Any]					,  __lowerCamelCase  :  int = 101  )				->				Tuple:

      '''simple docstring'''




      lowerCamelCase__	=  length

     def __len__(       self  :  str  )				->				List[Any]:

      '''simple docstring'''




      return self.length




     def __getitem__(       self  :  Optional[Any]					,  __lowerCamelCase  :  Any  )				->				int:

      '''simple docstring'''




      return i
 class 					lowercase							:


     '''simple docstring'''

     def __call__(       self  :  Optional[int]					,  __lowerCamelCase  :  List[str]  )				->				Any:

      '''simple docstring'''




      return {"input_ids": torch.tensor(__lowerCamelCase  ), "labels": torch.tensor(__lowerCamelCase  )}
 class 					lowercase							(				nn.Module   ):


     '''simple docstring'''

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

      '''simple docstring'''




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




     def  a__					(       self  :  Union[str, Any]					,  __lowerCamelCase  :  Any					,  __lowerCamelCase  :  Dict=None  )				->				Union[str, Any]:

      '''simple docstring'''




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






def  lowerCamelCase_  (     ):
 lowerCamelCase__	=  HfArgumentParser((TrainingArguments,))
 sys.argv += ["--output_dir", "./examples"]
 lowerCamelCase__	=  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]:
  lowerCamelCase__	=  DummyDataset(lowercase__)

  def compute_metrics(lowercase__) -> Dict:
   lowerCamelCase__	=  list(range(len(lowercase__)))
   lowerCamelCase__	=  p.predictions.tolist() == sequential and p.label_ids.tolist() == sequential
   return {"success": success}

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

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

  lowerCamelCase__	=  2

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

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

  lowerCamelCase__	=  None

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






def  lowerCamelCase_  (     lowercase__):
 # For xla_spawn (TPUs)
 main()


if __name__ == "__main__":
 main()









'''simple docstring'''





def  lowerCamelCase_  (     lowercase__):
 return int(lowercase__) if x - int(lowercase__) <= 0 else int(lowercase__) + 1


if __name__ == "__main__":
 import doctest

 doctest.testmod()

