





# 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 	_UpperCamelCase	(							A_	):







									'''simple docstring'''

									def __init__(    self     :	int			,       __lowercase     :	int = 1_01		):






										'''simple docstring'''







										UpperCAmelCase_		    =  length





									def __len__(    self     :	Dict		):






										'''simple docstring'''







										return self.length





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






										'''simple docstring'''







										return i







				class 	_UpperCamelCase	:







									'''simple docstring'''

									def __call__(    self     :	Optional[int]			,       __lowercase     :	Optional[int]		):






										'''simple docstring'''







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







				class 	_UpperCamelCase	(							nn.Module	):







									'''simple docstring'''

									def __init__(    self     :	List[Any]		):






										'''simple docstring'''







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





									def 							SCREAMING_SNAKE_CASE				(    self     :	Optional[int]			,       __lowercase     :	Dict			,       __lowercase     :	Optional[int]=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_(      ):
	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 ) -> 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 ):
	# For xla_spawn (TPUs)
	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() = }")


