



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


UpperCamelCase__    :     str			  =   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 							_lowerCAmelCase	(  A_							):


   """simple docstring"""

   def __init__(      self					,    _lowerCamelCase = 101  )    ->    Tuple:
      A_  :		Dict						=					length







   def __len__(      self  )    ->    Dict:
      return self.length







   def __getitem__(      self					,    _lowerCamelCase  )    ->    Tuple:
      return i


  class 							_lowerCAmelCase	:


   """simple docstring"""

   def __call__(      self					,    _lowerCamelCase  )    ->    Tuple:
      return {"input_ids": torch.tensor(__lowercase  ), "labels": torch.tensor(__lowercase  )}


  class 							_lowerCAmelCase	(  nn.Module							):


   """simple docstring"""

   def __init__(      self  )    ->    Optional[int]:
      super().__init__()
      # Add some (unused) params otherwise DDP will complain.
      A_  :		int						=					nn.Linear(120					,    80  )







   def       UpperCAmelCase_       (      self					,    _lowerCamelCase					,    _lowerCamelCase=None  )    ->    List[str]:







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



def     UpperCAmelCase     (    )   ->       List[str]:



   """simple docstring"""






   A_  :		int						=					HfArgumentParser((TrainingArguments,)		)
   sys.argv += ["--output_dir", "./examples"]
   A_  :		Dict						=					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 [1_0_0_1, 2_5_6, 1_5]:
      A_  :		int						=					DummyDataset(a_		)

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

      A_  :		Union[str, Any]						=					Trainer(
          model=DummyModel()      ,		args=a_      ,		data_collator=DummyDataCollator()      ,		eval_dataset=a_      ,		compute_metrics=a_      ,		)
      A_  :		Optional[Any]						=					trainer.evaluate()
      logger.info(a_		)
      if metrics["eval_success"] is not True:
         logger.error(a_		)
         exit(1		)

      A_  :		List[Any]						=					trainer.predict(a_		)
      logger.info(p.metrics		)
      if p.metrics["test_success"] is not True:
         logger.error(p.metrics		)
         exit(1		)

      A_  :		Union[str, Any]						=					2

      A_  :		List[Any]						=					trainer.evaluate()
      logger.info(a_		)
      if metrics["eval_success"] is not True:
         logger.error(a_		)
         exit(1		)

      A_  :		Optional[Any]						=					trainer.predict(a_		)
      logger.info(p.metrics		)
      if p.metrics["test_success"] is not True:
         logger.error(p.metrics		)
         exit(1		)

      A_  :		List[Any]						=					None

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



def     UpperCAmelCase     (    a_		)   ->       Dict:



   """simple docstring"""






   main()


if __name__ == "__main__":
  main()







def  A_(      A = 1000 ):
	UpperCAmelCase_		    =  0
	for i in range(A ):
		if i % 3 == 0 or i % 5 == 0:
			result += i
	return result


if __name__ == "__main__":
				print(f"{solution() = }")


