

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


lowerCAmelCase_     =      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   (    __lowerCAmelCase				):

										def __init__(       self,						lowercase_ = 101 )    ->							Optional[Any]:
											snake_case							=					length

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






										def __getitem__(       self,						lowercase_ )    ->							int:
											return i







						class lowerCamelCase   :

										def __call__(       self,						lowercase_ )    ->							Optional[int]:
											return {"input_ids": torch.tensor(lowercase_ ), "labels": torch.tensor(lowercase_ )}







						class lowerCamelCase   (    nn.Module				):

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






										def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_=None )    ->							Any:
											if labels is not None:
												return torch.tensor(0.0,						device=input_ids.device ), input_ids
											else:
												return input_ids

def      __magic_name__							(			)      ->		List[str]:
	snake_case							=					HfArgumentParser((TrainingArguments,)				)
	sys.argv += ["--output_dir", "./examples"]
	snake_case							=					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]:
		snake_case							=					DummyDataset(A				)

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

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

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

		snake_case							=					2

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

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

		snake_case							=					None

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

def      __magic_name__							(			A				)      ->		Optional[int]:
	# For xla_spawn (TPUs)
	main()


if __name__ == "__main__":
						main()








'''simple docstring'''

lowerCAmelCase_     =      "\n# Installation de Transformers\n! pip install transformers datasets\n# Pour installer à partir du code source au lieu de la dernière version, commentez la commande ci-dessus et décommentez la suivante.\n# ! pip install git+https://github.com/huggingface/transformers.git\n"

lowerCAmelCase_     =      [{"type": "code", "content": INSTALL_CONTENT}]
lowerCAmelCase_     =      {
    "{processor_class}": "FakeProcessorClass",
    "{model_class}": "FakeModelClass",
    "{object_class}": "FakeObjectClass",
}





