



from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
     import tensorflow as tf


snake_case__				= logging.get_logger(__name__)



@dataclass
class  UpperCamelCase				( UpperCAmelCase_ ):

     '''simple docstring'''

     A_										=  [
         'no_inference',
         'no_cuda',
         'no_tpu',
         'no_speed',
         'no_memory',
         'no_env_print',
         'no_multi_process',
     ]



     def __init__(					self				,				**A_						) ->				Tuple:






           """simple docstring"""
           for deprecated_arg in self.deprecated_args:
                 if deprecated_arg in kwargs:
                       _lowerCamelCase			    =				deprecated_arg[3:]
                       _lowerCamelCase			    =				not kwargs.pop(_lowercase						)
                       logger.warning(
                           F'{deprecated_arg} is depreciated. Please use --no-{positive_arg} or'
                           F' {positive_arg}={kwargs[positive_arg]}'						)
           _lowerCamelCase			    =				kwargs.pop('''tpu_name'''				,				self.tpu_name						)
           _lowerCamelCase			    =				kwargs.pop('''device_idx'''				,				self.device_idx						)
           _lowerCamelCase			    =				kwargs.pop('''eager_mode'''				,				self.eager_mode						)
           _lowerCamelCase			    =				kwargs.pop('''use_xla'''				,				self.use_xla						)
           super().__init__(**_lowercase						)

     A_										=  field(
         default=UpperCAmelCase_   ,  metadata={'help': 'Name of TPU'}   ,  )
     A_										=  field(
         default=0   ,  metadata={'help': 'CPU / GPU device index. Defaults to 0.'}   ,  )
     A_										=  field(default=UpperCAmelCase_   ,  metadata={'help': 'Benchmark models in eager model.'} )
     A_										=  field(
         default=UpperCAmelCase_   ,  metadata={
             'help': 'Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`.'
         }   ,  )



     @cached_property
     def 		UpperCamelCase_						(					self						) ->				Optional[int]:






           """simple docstring"""
           requires_backends(self				,				['''tf''']						)
           _lowerCamelCase			    =				None
           if self.tpu:
                 try:
                       if self.tpu_name:
                             _lowerCamelCase			    =				tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name						)
                       else:
                             _lowerCamelCase			    =				tf.distribute.cluster_resolver.TPUClusterResolver()
                 except ValueError:
                       _lowerCamelCase			    =				None
           return tpu



     @cached_property
     def 		UpperCamelCase_						(					self						) ->				int:






           """simple docstring"""
           requires_backends(self				,				['''tf''']						)
           if self.is_tpu:
                 tf.config.experimental_connect_to_cluster(self._setup_tpu						)
                 tf.tpu.experimental.initialize_tpu_system(self._setup_tpu						)

                 _lowerCamelCase			    =				tf.distribute.TPUStrategy(self._setup_tpu						)
           else:
                 # currently no multi gpu is allowed
                 if self.is_gpu:
                       # TODO: Currently only single GPU is supported
                       tf.config.set_visible_devices(self.gpu_list[self.device_idx]				,				'''GPU'''						)
                       _lowerCamelCase			    =				tf.distribute.OneDeviceStrategy(device=F'/gpu:{self.device_idx}'						)
                 else:
                       tf.config.set_visible_devices([]				,				'''GPU'''						)  # disable GPU
                       _lowerCamelCase			    =				tf.distribute.OneDeviceStrategy(device=F'/cpu:{self.device_idx}'						)

           return strategy



     @property
     def 		UpperCamelCase_						(					self						) ->				Union[str, Any]:






           """simple docstring"""
           requires_backends(self				,				['''tf''']						)
           return self._setup_tpu is not None



     @property
     def 		UpperCamelCase_						(					self						) ->				Any:






           """simple docstring"""
           requires_backends(self				,				['''tf''']						)
           return self._setup_strategy



     @property
     def 		UpperCamelCase_						(					self						) ->				int:






           """simple docstring"""
           requires_backends(self				,				['''tf''']						)
           return tf.config.list_physical_devices('''GPU'''						)



     @property
     def 		UpperCamelCase_						(					self						) ->				Union[str, Any]:






           """simple docstring"""
           requires_backends(self				,				['''tf''']						)
           if self.cuda:
                 return len(self.gpu_list						)
           return 0





     @property
     def 		UpperCamelCase_						(					self						) ->				Tuple:






           """simple docstring"""
           return self.n_gpu > 0
from .data_collator import (
    DataCollatorForLanguageModeling,
    DataCollatorForPermutationLanguageModeling,
    DataCollatorForSeqaSeq,
    DataCollatorForSOP,
    DataCollatorForTokenClassification,
    DataCollatorForWholeWordMask,
    DataCollatorWithPadding,
    DefaultDataCollator,
    default_data_collator,
)
from .metrics import glue_compute_metrics, xnli_compute_metrics
from .processors import (
    DataProcessor,
    InputExample,
    InputFeatures,
    SingleSentenceClassificationProcessor,
    SquadExample,
    SquadFeatures,
    SquadVaProcessor,
    SquadVaProcessor,
    glue_convert_examples_to_features,
    glue_output_modes,
    glue_processors,
    glue_tasks_num_labels,
    squad_convert_examples_to_features,
    xnli_output_modes,
    xnli_processors,
    xnli_tasks_num_labels,
)