




'''simple docstring'''







import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_video_inputs


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import VideoMAEImageProcessor

class   _snake_case( unittest.TestCase			):






 def __init__(self					:     List[str]						,		a					:     Optional[Any]						,		a					:     str=7						,		a					:     Optional[Any]=3						,		a					:     List[str]=10						,		a					:     int=18						,		a					:     Tuple=30						,		a					:     List[Any]=4_00						,		a					:     int=True						,		a					:     Optional[int]=None						,		a					:     Dict=True						,		a					:     int=[0.5, 0.5, 0.5]						,		a					:     str=[0.5, 0.5, 0.5]						,		a					:     List[str]=None						,		)					->      Optional[int]:






    """simple docstring"""


    A__         =    size if size is not None else {'shortest_edge': 18}
    A__         =    crop_size if crop_size is not None else {'height': 18, 'width': 18}

    A__         =    parent
    A__         =    batch_size
    A__         =    num_channels
    A__         =    num_frames
    A__         =    image_size
    A__         =    min_resolution
    A__         =    max_resolution
    A__         =    do_resize
    A__         =    size
    A__         =    do_normalize
    A__         =    image_mean
    A__         =    image_std
    A__         =    crop_size






 def 	_UpperCamelCase   (self					:     int						)					->      Optional[Any]:






    """simple docstring"""


    return {
        "image_mean": self.image_mean,
        "image_std": self.image_std,
        "do_normalize": self.do_normalize,
        "do_resize": self.do_resize,
        "size": self.size,
        "crop_size": self.crop_size,
    }




@require_torch
@require_vision
class   _snake_case( UpperCAmelCase					,   unittest.TestCase			):
 __snake_case:       Dict									=				VideoMAEImageProcessor if is_vision_available() else None






 def 	_UpperCamelCase   (self					:     List[str]						)					->      str:






    """simple docstring"""


    A__         =    VideoMAEImageProcessingTester(self						)






 @property
 def 	_UpperCamelCase   (self					:     str						)					->      Dict:






    """simple docstring"""


    return self.image_processor_tester.prepare_image_processor_dict()






 def 	_UpperCamelCase   (self					:     int						)					->      Tuple:






    """simple docstring"""


    A__         =    self.image_processing_class(**self.image_processor_dict						)
    self.assertTrue(hasattr(a						,		'image_mean'						)						)
    self.assertTrue(hasattr(a						,		'image_std'						)						)
    self.assertTrue(hasattr(a						,		'do_normalize'						)						)
    self.assertTrue(hasattr(a						,		'do_resize'						)						)
    self.assertTrue(hasattr(a						,		'do_center_crop'						)						)
    self.assertTrue(hasattr(a						,		'size'						)						)






 def 	_UpperCamelCase   (self					:     List[str]						)					->      List[Any]:






    """simple docstring"""


    A__         =    self.image_processing_class.from_dict(self.image_processor_dict						)
    self.assertEqual(image_processor.size						,		{'shortest_edge': 18}						)
    self.assertEqual(image_processor.crop_size						,		{'height': 18, 'width': 18}						)

    A__         =    self.image_processing_class.from_dict(self.image_processor_dict						,		size=42						,		crop_size=84						)
    self.assertEqual(image_processor.size						,		{'shortest_edge': 42}						)
    self.assertEqual(image_processor.crop_size						,		{'height': 84, 'width': 84}						)






 def 	_UpperCamelCase   (self					:     str						)					->      Any:






    """simple docstring"""


    pass






 def 	_UpperCamelCase   (self					:     Dict						)					->      Any:






    """simple docstring"""


    A__         =    self.image_processing_class(**self.image_processor_dict						)
    # create random PIL videos
    A__         =    prepare_video_inputs(self.image_processor_tester						,		equal_resolution=a						)
    for video in video_inputs:
       self.assertIsInstance(a						,		a						)
       self.assertIsInstance(video[0]						,		Image.Image						)

    # Test not batched input
    A__         =    image_processing(video_inputs[0]						,		return_tensors='pt'						).pixel_values
    self.assertEqual(
        encoded_videos.shape						,		(
            1,
            self.image_processor_tester.num_frames,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size['height'],
            self.image_processor_tester.crop_size['width'],
        )						,		)

    # Test batched
    A__         =    image_processing(a						,		return_tensors='pt'						).pixel_values
    self.assertEqual(
        encoded_videos.shape						,		(
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_frames,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size['height'],
            self.image_processor_tester.crop_size['width'],
        )						,		)






 def 	_UpperCamelCase   (self					:     Optional[Any]						)					->      str:






    """simple docstring"""


    A__         =    self.image_processing_class(**self.image_processor_dict						)
    # create random numpy tensors
    A__         =    prepare_video_inputs(self.image_processor_tester						,		equal_resolution=a						,		numpify=a						)
    for video in video_inputs:
       self.assertIsInstance(a						,		a						)
       self.assertIsInstance(video[0]						,		np.ndarray						)

    # Test not batched input
    A__         =    image_processing(video_inputs[0]						,		return_tensors='pt'						).pixel_values
    self.assertEqual(
        encoded_videos.shape						,		(
            1,
            self.image_processor_tester.num_frames,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size['height'],
            self.image_processor_tester.crop_size['width'],
        )						,		)

    # Test batched
    A__         =    image_processing(a						,		return_tensors='pt'						).pixel_values
    self.assertEqual(
        encoded_videos.shape						,		(
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_frames,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size['height'],
            self.image_processor_tester.crop_size['width'],
        )						,		)






 def 	_UpperCamelCase   (self					:     Any						)					->      Union[str, Any]:






    """simple docstring"""


    A__         =    self.image_processing_class(**self.image_processor_dict						)
    # create random PyTorch tensors
    A__         =    prepare_video_inputs(self.image_processor_tester						,		equal_resolution=a						,		torchify=a						)
    for video in video_inputs:
       self.assertIsInstance(a						,		a						)
       self.assertIsInstance(video[0]						,		torch.Tensor						)

    # Test not batched input
    A__         =    image_processing(video_inputs[0]						,		return_tensors='pt'						).pixel_values
    self.assertEqual(
        encoded_videos.shape						,		(
            1,
            self.image_processor_tester.num_frames,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size['height'],
            self.image_processor_tester.crop_size['width'],
        )						,		)

    # Test batched
    A__         =    image_processing(a						,		return_tensors='pt'						).pixel_values
    self.assertEqual(
        encoded_videos.shape						,		(
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_frames,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size['height'],
            self.image_processor_tester.crop_size['width'],
        )						,		)








'''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_    	=							logging.get_logger(__name__)

if is_tf_available():
    import tensorflow as tf

@dataclass
class   _snake_case( UpperCAmelCase			):
 __snake_case:       Optional[Any]									=				'''tf'''
 __snake_case:       Optional[str]									=				field(
     default=UpperCAmelCase					,   metadata={'''help''': '''Name of TPU'''}					,   )

 __snake_case:       Optional[str]									=				field(
     default=UpperCAmelCase					,   metadata={'''help''': '''Zone of TPU'''}					,   )

 __snake_case:       Optional[str]									=				field(
     default=UpperCAmelCase					,   metadata={'''help''': '''Name of Cloud TPU-enabled project'''}					,   )

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

 __snake_case:       bool									=				field(default=UpperCAmelCase					,   metadata={'''help''': '''Whether to activate the XLA compilation or not'''}			)






 @cached_property
 def 	_UpperCamelCase   (self					:     Tuple						)					->      Tuple["tf.distribute.Strategy", int]:






    """simple docstring"""


    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(a						)
          tf.tpu.experimental.initialize_tpu_system(a						)

          A__         =    tf.distribute.TPUStrategy(a						)

       elif len(a						) == 0:
          A__         =    tf.distribute.OneDeviceStrategy(device='/cpu:0'						)
       elif len(a						) == 1:
          A__         =    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`
          A__         =    tf.distribute.MirroredStrategy()
       else:
          raise ValueError('Cannot find the proper strategy, please check your environment properties.'						)

    return strategy






 @property
 def 	_UpperCamelCase   (self					:     List[Any]						)					->      "tf.distribute.Strategy":






    """simple docstring"""


    requires_backends(self						,		['tf']						)
    return self._setup_strategy






 @property
 def 	_UpperCamelCase   (self					:     Tuple						)					->      int:






    """simple docstring"""


    requires_backends(self						,		['tf']						)
    return self._setup_strategy.num_replicas_in_sync






 @property
 def 	_UpperCamelCase   (self					:     Optional[Any]						)					->      int:






    """simple docstring"""


    return False  # TF Logging is handled by Keras not the Trainer






 @property
 def 	_UpperCamelCase   (self					:     Union[str, Any]						)					->      int:






    """simple docstring"""


    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[int]						)					->      int:






    """simple docstring"""


    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[Any]						)					->      int:






    """simple docstring"""


    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


