






"""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__       :			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	):

     def __init__(       self			,					snake_case_ = 101   )		->							Union[str, Any]:
         UpperCamelCase__								=     length

     def __len__(       self   )		->							Union[str, Any]:
         return self.length







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







  class  __lowerCamelCase     :

     def __call__(       self			,					snake_case_   )		->							int:
         return {"input_ids": torch.tensor(snake_case_   ), "labels": torch.tensor(snake_case_   )}







  class  __lowerCamelCase     (	nn.Module	):

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







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







def 	lowerCAmelCase_(			)       ->						Union[str, Any]:
    """simple docstring"""

    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 [10_01, 2_56, 15]:
        UpperCamelCase__								=     DummyDataset(SCREAMING_SNAKE_CASE       )

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

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

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

        UpperCamelCase__								=     trainer.predict(SCREAMING_SNAKE_CASE       )
        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 	lowerCAmelCase_(			SCREAMING_SNAKE_CASE       )       ->						Tuple:
    """simple docstring"""

    main()


if __name__ == "__main__":
  main()












"""simple docstring"""





from collections import OrderedDict
from typing import Mapping

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


A__       :			Union[str, Any]=						logging.get_logger(__name__)

A__       :			Dict=						{
    """google/rembert""": """https://huggingface.co/google/rembert/resolve/main/config.json""",
    # See all RemBERT models at https://huggingface.co/models?filter=rembert
}
class  __lowerCamelCase     (	_a	):
   a   :					Optional[int]			    ="""rembert"""

   def __init__(       self			,					snake_case_=25_0300			,					snake_case_=1152			,					snake_case_=32			,					snake_case_=18			,					snake_case_=256			,					snake_case_=1664			,					snake_case_=4608			,					snake_case_="gelu"			,					snake_case_=0.0			,					snake_case_=0.0			,					snake_case_=0.1			,					snake_case_=512			,					snake_case_=2			,					snake_case_=0.02			,					snake_case_=1E-12			,					snake_case_=True			,					snake_case_=0			,					snake_case_=312			,					snake_case_=313			,					**snake_case_			,					)		->							str:
       super().__init__(pad_token_id=snake_case_			,					bos_token_id=snake_case_			,					eos_token_id=snake_case_			,					**snake_case_   )

       UpperCamelCase__								=     vocab_size
       UpperCamelCase__								=     input_embedding_size
       UpperCamelCase__								=     output_embedding_size
       UpperCamelCase__								=     max_position_embeddings
       UpperCamelCase__								=     hidden_size
       UpperCamelCase__								=     num_hidden_layers
       UpperCamelCase__								=     num_attention_heads
       UpperCamelCase__								=     intermediate_size
       UpperCamelCase__								=     hidden_act
       UpperCamelCase__								=     hidden_dropout_prob
       UpperCamelCase__								=     attention_probs_dropout_prob
       UpperCamelCase__								=     classifier_dropout_prob
       UpperCamelCase__								=     initializer_range
       UpperCamelCase__								=     type_vocab_size
       UpperCamelCase__								=     layer_norm_eps
       UpperCamelCase__								=     use_cache
       UpperCamelCase__								=     False







class  __lowerCamelCase     (	_a	):

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







   @property
   def     SCREAMING_SNAKE_CASE__			(       self   )		->							float:
       return 1E-4




