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
  
  
  A_			  =    logging.get_logger(__name__)
  
  if is_tf_available():
      import tensorflow as tf
  @dataclass
  class 						__lowerCAmelCase   (			UpperCAmelCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    __lowerCamelCase       :    Any     	=			"tf"
    __lowerCamelCase       :    Optional[str]     	=			field(
        default=UpperCAmelCase       ,   metadata={"help": "Name of TPU"}       ,   )
  
    __lowerCamelCase       :    Optional[str]     	=			field(
        default=UpperCAmelCase       ,   metadata={"help": "Zone of TPU"}       ,   )
  
    __lowerCamelCase       :    Optional[str]     	=			field(
        default=UpperCAmelCase       ,   metadata={"help": "Name of Cloud TPU-enabled project"}       ,   )
  
    __lowerCamelCase       :    float     	=			field(
        default=1.0       ,   metadata={"help": "Power for the Polynomial decay LR scheduler."}       ,   )
  
    __lowerCamelCase       :    bool     	=			field(default=UpperCAmelCase       ,   metadata={"help": "Whether to activate the XLA compilation or not"}       )
    @cached_property
    def 					UpperCamelCase__   (      self:		Tuple					):
       requires_backends(self				,			["tf"]					)
       logger.info("Tensorflow: setting up strategy"					)
  
       UpperCamelCase_     =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:
          UpperCamelCase_     =tf.distribute.OneDeviceStrategy(device="/cpu:0"					)
       else:
          try:
             if self.tpu_name:
                UpperCamelCase_     =tf.distribute.cluster_resolver.TPUClusterResolver(
                    self.tpu_name				,			zone=self.tpu_zone				,			project=self.gcp_project					)
             else:
                UpperCamelCase_     =tf.distribute.cluster_resolver.TPUClusterResolver()
          except ValueError:
             if self.tpu_name:
                raise RuntimeError(f"""Couldn't connect to TPU {self.tpu_name}!"""					)
             else:
                UpperCamelCase_     =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(UpperCamelCase_					)
             tf.tpu.experimental.initialize_tpu_system(UpperCamelCase_					)
  
             UpperCamelCase_     =tf.distribute.TPUStrategy(UpperCamelCase_					)
  
          elif len(UpperCamelCase_					) == 0:
             UpperCamelCase_     =tf.distribute.OneDeviceStrategy(device="/cpu:0"					)
          elif len(UpperCamelCase_					) == 1:
             UpperCamelCase_     =tf.distribute.OneDeviceStrategy(device="/gpu:0"					)
          elif len(UpperCamelCase_					) > 1:
             # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
             UpperCamelCase_     =tf.distribute.MirroredStrategy()
          else:
             raise ValueError("Cannot find the proper strategy, please check your environment properties."					)
  
       return strategy
    @property
    def 					UpperCamelCase__   (      self:		Optional[Any]					):
       requires_backends(self				,			["tf"]					)
       return self._setup_strategy
    @property
    def 					UpperCamelCase__   (      self:		Dict					):
       requires_backends(self				,			["tf"]					)
       return self._setup_strategy.num_replicas_in_sync
    @property
    def 					UpperCamelCase__   (      self:		str					):
       return False  # TF Logging is handled by Keras not the Trainer
    @property
    def 					UpperCamelCase__   (      self:		Dict					):
       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."					)
       UpperCamelCase_     =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:		Union[str, Any]					):
       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."					)
       UpperCamelCase_     =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:		List[Any]					):
       requires_backends(self				,			["tf"]					)
       warnings.warn(
           "The n_gpu argument is deprecated and will be removed in a future version, use n_replicas instead."				,			UpperCamelCase_				,			)
       return self._setup_strategy.num_replicas_in_sync
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  import warnings
  
  from ...processing_utils import ProcessorMixin
  from ...tokenization_utils_base import BatchEncoding
  class 						__lowerCAmelCase   (			UpperCAmelCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    __lowerCamelCase       :    Optional[Any]     	=			["image_processor", "tokenizer"]
    __lowerCamelCase       :    List[str]     	=			"VideoMAEImageProcessor"
    __lowerCamelCase       :    Dict     	=			("CLIPTokenizer", "CLIPTokenizerFast")
    def __init__(      self:		str				,			UpperCamelCase_:		Dict=None				,			UpperCamelCase_:		str=None				,			**UpperCamelCase_:		str					):
       UpperCamelCase_     =None
       if "feature_extractor" in kwargs:
          warnings.warn(
              "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
              " instead."				,			UpperCamelCase_				,			)
          UpperCamelCase_     =kwargs.pop("feature_extractor"					)
  
       UpperCamelCase_     =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__(UpperCamelCase_				,			UpperCamelCase_					)
       UpperCamelCase_     =self.image_processor
    def __call__(      self:		Tuple				,			UpperCamelCase_:		str=None				,			UpperCamelCase_:		str=None				,			UpperCamelCase_:		Optional[Any]=None				,			**UpperCamelCase_:		int					):
  
       if text is None and videos is None:
          raise ValueError("You have to specify either text or videos. Both cannot be none."					)
  
       if text is not None:
          UpperCamelCase_     =self.tokenizer(UpperCamelCase_				,			return_tensors=UpperCamelCase_				,			**UpperCamelCase_					)
  
       if videos is not None:
          UpperCamelCase_     =self.image_processor(UpperCamelCase_				,			return_tensors=UpperCamelCase_				,			**UpperCamelCase_					)
  
       if text is not None and videos is not None:
          UpperCamelCase_     =image_features.pixel_values
          return encoding
       elif text is not None:
          return encoding
       else:
          return BatchEncoding(data=dict(**UpperCamelCase_					)				,			tensor_type=UpperCamelCase_					)
    def 					UpperCamelCase__   (      self:		Any				,			*UpperCamelCase_:		List[str]				,			**UpperCamelCase_:		Optional[int]					):
       return self.tokenizer.batch_decode(*UpperCamelCase_				,			**UpperCamelCase_					)
    def 					UpperCamelCase__   (      self:		Optional[Any]				,			*UpperCamelCase_:		List[str]				,			**UpperCamelCase_:		Tuple					):
       return self.tokenizer.decode(*UpperCamelCase_				,			**UpperCamelCase_					)
    @property
    def 					UpperCamelCase__   (      self:		List[Any]					):
       return ["input_ids", "attention_mask", "position_ids", "pixel_values"]
    @property
    def 					UpperCamelCase__   (      self:		str					):
       warnings.warn(
           "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."				,			UpperCamelCase_				,			)
       return self.image_processor_class
  
  
  
  
  
    @property
    def 					UpperCamelCase__   (      self:		Optional[Any]					):
       warnings.warn(
           "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."				,			UpperCamelCase_				,			)
       return self.image_processor
  