
import warnings
from dataclasses import dataclass, field
from typing import Optional, Tuple

from .training_args import TrainingArguments
from .utils import cached_property, is_tf_available, logging, requires_backends


_UpperCAmelCase    			=					logging.get_logger(__name__)

if is_tf_available():
  import tensorflow as tf

@dataclass
class 		__magic_name__				( lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = "tf"
  _UpperCamelCase						 = field(
      default=lowercase_						,metadata={"help": "Name of TPU"}						,)

  _UpperCamelCase						 = field(
      default=lowercase_						,metadata={"help": "Zone of TPU"}						,)

  _UpperCamelCase						 = field(
      default=lowercase_						,metadata={"help": "Name of Cloud TPU-enabled project"}						,)

  _UpperCamelCase						 = field(
      default=1.0						,metadata={"help": "Power for the Polynomial decay LR scheduler."}						,)

  _UpperCamelCase						 = field(default=lowercase_						,metadata={"help": "Whether to activate the XLA compilation or not"}					)


  @cached_property
  def     _UpperCAmelCase  (					self		):
    requires_backends(self	,		['''tf''']		)
    logger.info('''Tensorflow: setting up strategy'''		)

    _lowerCamelCase      =						tf.config.list_physical_devices('''GPU'''		)

    # Set to float16 at first
    if self.fpaa:
      tf.keras.mixed_precision.set_global_policy('''mixed_float16'''		)

    if self.no_cuda:
      _lowerCamelCase      =						tf.distribute.OneDeviceStrategy(device='''/cpu:0'''		)
    else:
      try:
        if self.tpu_name:
          _lowerCamelCase      =						tf.distribute.cluster_resolver.TPUClusterResolver(
              self.tpu_name	,		zone=self.tpu_zone	,		project=self.gcp_project		)
        else:
          _lowerCamelCase      =						tf.distribute.cluster_resolver.TPUClusterResolver()
      except ValueError:
        if self.tpu_name:
          raise RuntimeError(f'''Couldn\'t connect to TPU {self.tpu_name}!'''		)
        else:
          _lowerCamelCase      =						None

      if tpu:
        # Set to bfloat16 in case of TPU
        if self.fpaa:
          tf.keras.mixed_precision.set_global_policy('''mixed_bfloat16'''		)

        tf.config.experimental_connect_to_cluster(a__		)
        tf.tpu.experimental.initialize_tpu_system(a__		)

        _lowerCamelCase      =						tf.distribute.TPUStrategy(a__		)

      elif len(a__		) == 0:
        _lowerCamelCase      =						tf.distribute.OneDeviceStrategy(device='''/cpu:0'''		)
      elif len(a__		) == 1:
        _lowerCamelCase      =						tf.distribute.OneDeviceStrategy(device='''/gpu:0'''		)
      elif len(a__		) > 1:
        # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
        _lowerCamelCase      =						tf.distribute.MirroredStrategy()
      else:
        raise ValueError('''Cannot find the proper strategy, please check your environment properties.'''		)

    return strategy


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


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


  @property
  def     _UpperCAmelCase  (					self		):
    return False  # TF Logging is handled by Keras not the Trainer


  @property
  def     _UpperCAmelCase  (					self		):
    if self.per_gpu_train_batch_size:
      logger.warning(
          '''Using deprecated `--per_gpu_train_batch_size` argument which will be removed in a future '''
          '''version. Using `--per_device_train_batch_size` is preferred.'''		)
    _lowerCamelCase      =						self.per_gpu_train_batch_size or self.per_device_train_batch_size
    return per_device_batch_size * self.n_replicas


  @property
  def     _UpperCAmelCase  (					self		):
    if self.per_gpu_eval_batch_size:
      logger.warning(
          '''Using deprecated `--per_gpu_eval_batch_size` argument which will be removed in a future '''
          '''version. Using `--per_device_eval_batch_size` is preferred.'''		)
    _lowerCamelCase      =						self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
    return per_device_batch_size * self.n_replicas


  @property
  def     _UpperCAmelCase  (					self		):
    requires_backends(self	,		['''tf''']		)
    warnings.warn(
        '''The n_gpu argument is deprecated and will be removed in a future version, use n_replicas instead.'''	,		a__	,		)
    return self._setup_strategy.num_replicas_in_sync






import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin

class 		__magic_name__				( lowercase_					):


  """simple docstring"""





  _UpperCamelCase						 = ["image_processor", "tokenizer"]
  _UpperCamelCase						 = "AutoImageProcessor"
  _UpperCamelCase						 = "AutoTokenizer"


  def __init__(					self	,		a__=None	,		a__=None	,		**a__		):
    _lowerCamelCase      =						None
    if "feature_extractor" in kwargs:
      warnings.warn(
          '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
          ''' instead.'''	,		a__	,		)
      _lowerCamelCase      =						kwargs.pop('''feature_extractor'''		)

    _lowerCamelCase      =						image_processor if image_processor is not None else feature_extractor
    if image_processor is None:
      raise ValueError('''You need to specify an `image_processor`.'''		)
    if tokenizer is None:
      raise ValueError('''You need to specify a `tokenizer`.'''		)

    super().__init__(a__	,		a__		)
    _lowerCamelCase      =						self.image_processor
    _lowerCamelCase      =						False


  def __call__(					self	,		*a__	,		**a__		):
    # For backward compatibility
    if self._in_target_context_manager:
      return self.current_processor(*a__	,		**a__		)

    _lowerCamelCase      =						kwargs.pop('''images'''	,		a__		)
    _lowerCamelCase      =						kwargs.pop('''text'''	,		a__		)
    if len(a__		) > 0:
      _lowerCamelCase      =						args[0]
      _lowerCamelCase      =						args[1:]

    if images is None and text is None:
      raise ValueError('''You need to specify either an `images` or `text` input to process.'''		)

    if images is not None:
      _lowerCamelCase      =						self.image_processor(a__	,		*a__	,		**a__		)
    if text is not None:
      _lowerCamelCase      =						self.tokenizer(a__	,		**a__		)

    if text is None:
      return inputs
    elif images is None:
      return encodings
    else:
      _lowerCamelCase      =						encodings['''input_ids''']
      return inputs


  def     _UpperCAmelCase  (					self	,		*a__	,		**a__		):
    return self.tokenizer.batch_decode(*a__	,		**a__		)


  def     _UpperCAmelCase  (					self	,		*a__	,		**a__		):
    return self.tokenizer.decode(*a__	,		**a__		)


  @contextmanager
  def     _UpperCAmelCase  (					self		):
    warnings.warn(
        '''`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '''
        '''labels by using the argument `text` of the regular `__call__` method (either in the same call as '''
        '''your images inputs, or in a separate call.'''		)
    _lowerCamelCase      =						True
    _lowerCamelCase      =						self.tokenizer
    yield
    _lowerCamelCase      =						self.image_processor
    _lowerCamelCase      =						False


  @property
  def     _UpperCAmelCase  (					self		):
    warnings.warn(
        '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''	,		a__	,		)
    return self.image_processor_class


  @property
  def     _UpperCAmelCase  (					self		):
    warnings.warn(
        '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''	,		a__	,		)
    return self.image_processor




