code: 
  
  
  
  
  
  '''simple docstring'''
  
  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
  
  
  __lowerCAmelCase							:			Dict				=logging.get_logger(__name__)
  
  if is_tf_available():
    import tensorflow as tf
  
  
  
  
  
  
  @dataclass
  class      UpperCAmelCase			( UpperCamelCase__       ):
   __lowercase     	=       """tf"""
   __lowercase     	=       field(
       default=UpperCamelCase__    , metadata={"""help""": """Name of TPU"""}    , )
  
   __lowercase     	=       field(
       default=UpperCamelCase__    , metadata={"""help""": """Zone of TPU"""}    , )
  
   __lowercase     	=       field(
       default=UpperCamelCase__    , metadata={"""help""": """Name of Cloud TPU-enabled project"""}    , )
  
   __lowercase     	=       field(
       default=1.0    , metadata={"""help""": """Power for the Polynomial decay LR scheduler."""}    , )
  
   __lowercase     	=       field(default=UpperCamelCase__    , metadata={"""help""": """Whether to activate the XLA compilation or not"""}       )
   @cached_property
   def   UpperCAmelCase_							(       self   :List[Any]							)->							Tuple["tf.distribute.Strategy", int]:
       requires_backends(self		, ["tf"]							)
       logger.info("Tensorflow: setting up strategy"							)
  
       A__       =    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:
           A__       =    tf.distribute.OneDeviceStrategy(device="/cpu:0"							)
       else:
           try:
               if self.tpu_name:
                   A__       =    tf.distribute.cluster_resolver.TPUClusterResolver(
                       self.tpu_name		, zone=self.tpu_zone		, project=self.gcp_project							)
               else:
                   A__       =    tf.distribute.cluster_resolver.TPUClusterResolver()
           except ValueError:
               if self.tpu_name:
                   raise RuntimeError(F"Couldn't connect to TPU {self.tpu_name}!"							)
               else:
                   A__       =    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(lowercase_							)
               tf.tpu.experimental.initialize_tpu_system(lowercase_							)
  
               A__       =    tf.distribute.TPUStrategy(lowercase_							)
  
           elif len(lowercase_							) == 0:
               A__       =    tf.distribute.OneDeviceStrategy(device="/cpu:0"							)
           elif len(lowercase_							) == 1:
               A__       =    tf.distribute.OneDeviceStrategy(device="/gpu:0"							)
           elif len(lowercase_							) > 1:
               # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
               A__       =    tf.distribute.MirroredStrategy()
           else:
               raise ValueError("Cannot find the proper strategy, please check your environment properties."							)
  
       return strategy
   @property
   def   UpperCAmelCase_							(       self   :str							)->							"tf.distribute.Strategy":
       requires_backends(self		, ["tf"]							)
       return self._setup_strategy
   @property
   def   UpperCAmelCase_							(       self   :List[Any]							)->							int:
       requires_backends(self		, ["tf"]							)
       return self._setup_strategy.num_replicas_in_sync
   @property
   def   UpperCAmelCase_							(       self   :Any							)->							List[str]:
       return False  # TF Logging is handled by Keras not the Trainer
   @property
   def   UpperCAmelCase_							(       self   :str							)->							int:
       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."							)
       A__       =    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   :Optional[Any]							)->							int:
       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."							)
       A__       =    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   :Optional[int]							)->							int:
       requires_backends(self		, ["tf"]							)
       warnings.warn(
           "The n_gpu argument is deprecated and will be removed in a future version, use n_replicas instead."		, lowercase_		, )
       return self._setup_strategy.num_replicas_in_sync
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  import warnings
  
  from ...utils import logging
  from .image_processing_vilt import ViltImageProcessor
  
  
  __lowerCAmelCase							:			Dict				=logging.get_logger(__name__)
  
  
  
  
  
  
  class      UpperCAmelCase			( UpperCamelCase__       ):
   def __init__(       self   :List[str]		, *lowercase_   :Dict		, **lowercase_   :int							)->							None:
       warnings.warn(
           "The class ViltFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"
           " use ViltImageProcessor instead."		, lowercase_		, )
       super().__init__(*lowercase_		, **lowercase_							)
  
  
  
  