





'''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










'''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_							)



