





"""simple docstring"""






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


lowerCAmelCase_			=							logging.get_logger(__name__)



@dataclass
class 	lowerCAmelCase					(      snake_case							):
    lowerCAmelCase__						 =  [
        """no_inference""",
        """no_cuda""",
        """no_tpu""",
        """no_speed""",
        """no_memory""",
        """no_env_print""",
        """no_multi_process""",
    ]






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

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






    @cached_property
    def 							__A (   self     ):
           requires_backends(self    ,  ['tf']     )
           _UpperCAmelCase     =     None
           if self.tpu:
                  try:
                         if self.tpu_name:
                                _UpperCAmelCase     =     tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name     )
                         else:
                                _UpperCAmelCase     =     tf.distribute.cluster_resolver.TPUClusterResolver()
                  except ValueError:
                         _UpperCAmelCase     =     None
           return tpu






    @cached_property
    def 							__A (   self     ):
           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     )

                  _UpperCAmelCase     =     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'     )
                         _UpperCAmelCase     =     tf.distribute.OneDeviceStrategy(device=f"""/gpu:{self.device_idx}"""     )
                  else:
                         tf.config.set_visible_devices([]    ,  'GPU'     )  # disable GPU
                         _UpperCAmelCase     =     tf.distribute.OneDeviceStrategy(device=f"""/cpu:{self.device_idx}"""     )

           return strategy






    @property
    def 							__A (   self     ):
           requires_backends(self    ,  ['tf']     )
           return self._setup_tpu is not None






    @property
    def 							__A (   self     ):
           requires_backends(self    ,  ['tf']     )
           return self._setup_strategy






    @property
    def 							__A (   self     ):
           requires_backends(self    ,  ['tf']     )
           return tf.config.list_physical_devices('GPU'     )






    @property
    def 							__A (   self     ):
           requires_backends(self    ,  ['tf']     )
           if self.cuda:
                  return len(self.gpu_list     )
           return 0






    @property
    def 							__A (   self     ):
           return self.n_gpu > 0













"""simple docstring"""






from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase_			=							logging.get_logger(__name__)

lowerCAmelCase_			=							{
    '''microsoft/trocr-base-handwritten''': (
        '''https://huggingface.co/microsoft/trocr-base-handwritten/resolve/main/config.json'''
    ),
    # See all TrOCR models at https://huggingface.co/models?filter=trocr
}



class 	lowerCAmelCase					(      snake_case							):
       lowerCAmelCase__						 =  """trocr"""
       lowerCAmelCase__						 =  ["""past_key_values"""]
       lowerCAmelCase__						 =  {
           """num_attention_heads""": """decoder_attention_heads""",
           """hidden_size""": """d_model""",
           """num_hidden_layers""": """decoder_layers""",
       }






       def __init__(   self    ,  a__=5_02_65    ,  a__=10_24    ,  a__=12    ,  a__=16    ,  a__=40_96    ,  a__="gelu"    ,  a__=5_12    ,  a__=0.1    ,  a__=0.0    ,  a__=0.0    ,  a__=2    ,  a__=0.02    ,  a__=0.0    ,  a__=True    ,  a__=False    ,  a__=True    ,  a__=True    ,  a__=1    ,  a__=0    ,  a__=2    ,  **a__    ,  ):
              _UpperCAmelCase     =     vocab_size
              _UpperCAmelCase     =     d_model
              _UpperCAmelCase     =     decoder_layers
              _UpperCAmelCase     =     decoder_attention_heads
              _UpperCAmelCase     =     decoder_ffn_dim
              _UpperCAmelCase     =     activation_function
              _UpperCAmelCase     =     max_position_embeddings
              _UpperCAmelCase     =     dropout
              _UpperCAmelCase     =     attention_dropout
              _UpperCAmelCase     =     activation_dropout
              _UpperCAmelCase     =     init_std
              _UpperCAmelCase     =     decoder_layerdrop
              _UpperCAmelCase     =     use_cache
              _UpperCAmelCase     =     scale_embedding
              _UpperCAmelCase     =     use_learned_position_embeddings
              _UpperCAmelCase     =     layernorm_embedding

              super().__init__(
                  pad_token_id=a__    ,  bos_token_id=a__    ,  eos_token_id=a__    ,  decoder_start_token_id=a__    ,  **a__    ,  )






