

'''simple docstring'''


from typing import Dict

from transformers import EvalPrediction, HfArgumentParser, TrainingArguments, is_torch_available
from transformers.testing_utils import (
    TestCasePlus,
    execute_subprocess_async,
    get_torch_dist_unique_port,
    require_torch_multi_gpu,
    require_torch_neuroncore,
)
from transformers.training_args import ParallelMode
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 					lowercase						(  a_ ):


													def __init__(			self    ,			_snake_case = 101)							->				Any:
														UpperCAmelCase_		:      int       	=					length


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





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



						class 					lowercase						:


													def __call__(			self    ,			_snake_case)							->				List[str]:
														return {"input_ids": torch.tensor(_snake_case), "labels": torch.tensor(_snake_case)}



						class 					lowercase						(  nn.Module ):


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





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



class 					lowercase						(  a_ ):


							@require_torch_neuroncore
							def 						_snake_case							(			self)							->				str:
								UpperCAmelCase_		:      List[str]       	=					F"""--nproc_per_node=2
            --master_port={get_torch_dist_unique_port()}
            {self.test_file_dir}/test_trainer_distributed.py
        """.split()
								UpperCAmelCase_		:      List[str]       	=					self.get_auto_remove_tmp_dir()
								UpperCAmelCase_		:      Tuple       	=					F"""--output_dir {output_dir}""".split()
								UpperCAmelCase_		:      int       	=					['torchrun'] + distributed_args + args
								execute_subprocess_async(_snake_case    ,			env=self.get_env())
								# successful return here == success - any errors would have caused an error in the sub-call



class 					lowercase						(  a_ ):


							@require_torch_multi_gpu
							def 						_snake_case							(			self)							->				List[Any]:
								UpperCAmelCase_		:      Any       	=					F"""--nproc_per_node={torch.cuda.device_count()}
            --master_port={get_torch_dist_unique_port()}
            {self.test_file_dir}/test_trainer_distributed.py
        """.split()
								UpperCAmelCase_		:      Optional[int]       	=					self.get_auto_remove_tmp_dir()
								UpperCAmelCase_		:      Union[str, Any]       	=					F"""--output_dir {output_dir}""".split()
								UpperCAmelCase_		:      Any       	=					['torchrun'] + distributed_args + args
								execute_subprocess_async(_snake_case    ,			env=self.get_env())
								# successful return here == success - any errors would have caused an error in the sub-call


if __name__ == "__main__":
						# The script below is meant to be run under torch.distributed, on a machine with multiple GPUs:
						#
						# PYTHONPATH="src" python -m torch.distributed.run --nproc_per_node 2 --output_dir output_dir ./tests/test_trainer_distributed.py

						lowerCAmelCase__										= HfArgumentParser((TrainingArguments,))
						lowerCAmelCase__										= parser.parse_args_into_dataclasses()[0]

						logger.warning(
						    F'Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}, '
						    F'distributed training: {training_args.parallel_mode != ParallelMode.NOT_DISTRIBUTED}'
						)

						# 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 [101, 40, 7]:
												lowerCAmelCase__										= DummyDataset(dataset_length)







												def 						SCREAMING_SNAKE_CASE(  UpperCamelCase  )    ->    Dict:
													UpperCAmelCase_		:      str       	=					list(range(len(UpperCamelCase  )  )  )
													UpperCAmelCase_		:      Tuple       	=					p.predictions.tolist() == sequential and p.label_ids.tolist() == sequential
													if not success and training_args.local_rank == 0:
														logger.warning(
														    'Predictions and/or labels do not match expected results:\n  - predictions: '
														    f"""{p.predictions.tolist()}\n  - labels: {p.label_ids.tolist()}\n  - expected: {sequential}"""  )
													return {"success": success}

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

												lowerCAmelCase__										= trainer.predict(dataset)
												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(metrics)
												if metrics["eval_success"] is not True:
																		logger.error(metrics)
																		exit(1)

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







												lowerCAmelCase__										= None









'''simple docstring'''


from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowerCAmelCase__										= logging.get_logger(__name__)

lowerCAmelCase__										= {
    "facebook/xlm-roberta-xl": "https://huggingface.co/facebook/xlm-roberta-xl/resolve/main/config.json",
    "facebook/xlm-roberta-xxl": "https://huggingface.co/facebook/xlm-roberta-xxl/resolve/main/config.json",
    # See all XLM-RoBERTa-XL models at https://huggingface.co/models?filter=xlm-roberta-xl
}



class 					lowercase						(  a_ ):
							_lowerCamelCase		:      Any=   "xlm-roberta-xl"


							def __init__(			self    ,			_snake_case=25_0880    ,			_snake_case=2560    ,			_snake_case=36    ,			_snake_case=32    ,			_snake_case=1_0240    ,			_snake_case="gelu"    ,			_snake_case=0.1    ,			_snake_case=0.1    ,			_snake_case=514    ,			_snake_case=1    ,			_snake_case=0.02    ,			_snake_case=1e-05    ,			_snake_case=1    ,			_snake_case=0    ,			_snake_case=2    ,			_snake_case="absolute"    ,			_snake_case=True    ,			_snake_case=None    ,			**_snake_case    ,			)							->				Optional[Any]:
								super().__init__(pad_token_id=_snake_case    ,			bos_token_id=_snake_case    ,			eos_token_id=_snake_case    ,			**_snake_case)
								UpperCAmelCase_		:      List[str]       	=					vocab_size
								UpperCAmelCase_		:      int       	=					hidden_size
								UpperCAmelCase_		:      List[Any]       	=					num_hidden_layers
								UpperCAmelCase_		:      Optional[int]       	=					num_attention_heads
								UpperCAmelCase_		:      Union[str, Any]       	=					hidden_act
								UpperCAmelCase_		:      int       	=					intermediate_size
								UpperCAmelCase_		:      Tuple       	=					hidden_dropout_prob
								UpperCAmelCase_		:      List[str]       	=					attention_probs_dropout_prob
								UpperCAmelCase_		:      str       	=					max_position_embeddings
								UpperCAmelCase_		:      Union[str, Any]       	=					type_vocab_size
								UpperCAmelCase_		:      str       	=					initializer_range
								UpperCAmelCase_		:      List[str]       	=					layer_norm_eps
								UpperCAmelCase_		:      Dict       	=					position_embedding_type
								UpperCAmelCase_		:      int       	=					use_cache
								UpperCAmelCase_		:      List[Any]       	=					classifier_dropout



class 					lowercase						(  a_ ):


							@property
							def 						_snake_case							(			self)							->				Mapping[str, Mapping[int, str]]:
								if self.task == "multiple-choice":
									UpperCAmelCase_		:      Any       	=					{0: 'batch', 1: 'choice', 2: 'sequence'}
								else:
									UpperCAmelCase_		:      Optional[int]       	=					{0: 'batch', 1: 'sequence'}
								return OrderedDict(
								    [
								        ('input_ids', dynamic_axis),
								        ('attention_mask', dynamic_axis),
								    ])






