


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_image_inputs


if is_torch_available():
       import torch

if is_vision_available():
       from PIL import Image

       from transformers import MobileNetVaImageProcessor


class 	a__						(    unittest.TestCase     ):

       def __init__( self   :  Union[str, Any]   ,				lowerCamelCase_   :  List[str]   ,				lowerCamelCase_   :  Dict=7   ,				lowerCamelCase_   :  Optional[Any]=3   ,				lowerCamelCase_   :  Union[str, Any]=1_8   ,				lowerCamelCase_   :  Any=3_0   ,				lowerCamelCase_   :  int=4_0_0   ,				lowerCamelCase_   :  List[str]=True   ,				lowerCamelCase_   :  Dict=None   ,				lowerCamelCase_   :  Union[str, Any]=True   ,				lowerCamelCase_   :  Tuple=None   ,				):
            a_     :  Dict				      =     size if size is not None else {"""shortest_edge""": 2_0}
            a_     :  Optional[int]				      =     crop_size if crop_size is not None else {"""height""": 1_8, """width""": 1_8}
            a_     :  Tuple				      =     parent
            a_     :  Optional[int]				      =     batch_size
            a_     :  Union[str, Any]				      =     num_channels
            a_     :  List[str]				      =     image_size
            a_     :  int				      =     min_resolution
            a_     :  Union[str, Any]				      =     max_resolution
            a_     :  Union[str, Any]				      =     do_resize
            a_     :  int				      =     size
            a_     :  int				      =     do_center_crop
            a_     :  Any				      =     crop_size

       def     UpperCAmelCase( self   :  List[Any]     ):
            return {
                "do_resize": self.do_resize,
                "size": self.size,
                "do_center_crop": self.do_center_crop,
                "crop_size": self.crop_size,
            }


@require_torch
@require_vision
class 	a__						(    lowerCAmelCase_    ,							unittest.TestCase     ):
       lowerCamelCase__:  Union[str, Any]				     =  MobileNetVaImageProcessor if is_vision_available() else None

       def     UpperCAmelCase( self   :  Tuple     ):
            a_     :  Any				      =     MobileNetVaImageProcessingTester(self     )

       @property
       def     UpperCAmelCase( self   :  Optional[int]     ):
            return self.image_processor_tester.prepare_image_processor_dict()

       def     UpperCAmelCase( self   :  List[str]     ):
            a_     :  int				      =     self.image_processing_class(**self.image_processor_dict     )
            self.assertTrue(hasattr(lowerCamelCase_   ,				"""do_resize"""     )     )
            self.assertTrue(hasattr(lowerCamelCase_   ,				"""size"""     )     )
            self.assertTrue(hasattr(lowerCamelCase_   ,				"""do_center_crop"""     )     )
            self.assertTrue(hasattr(lowerCamelCase_   ,				"""center_crop"""     )     )

       def     UpperCAmelCase( self   :  Dict     ):
            a_     :  List[Any]				      =     self.image_processing_class.from_dict(self.image_processor_dict     )
            self.assertEqual(image_processor.size   ,				{"""shortest_edge""": 2_0}     )
            self.assertEqual(image_processor.crop_size   ,				{"""height""": 1_8, """width""": 1_8}     )

            a_     :  str				      =     self.image_processing_class.from_dict(self.image_processor_dict   ,				size=4_2   ,				crop_size=8_4     )
            self.assertEqual(image_processor.size   ,				{"""shortest_edge""": 4_2}     )
            self.assertEqual(image_processor.crop_size   ,				{"""height""": 8_4, """width""": 8_4}     )

       def     UpperCAmelCase( self   :  List[str]     ):
            pass

       def     UpperCAmelCase( self   :  Any     ):
            # Initialize image_processing
            a_     :  str				      =     self.image_processing_class(**self.image_processor_dict     )
            # create random PIL images
            a_     :  int				      =     prepare_image_inputs(self.image_processor_tester   ,				equal_resolution=lowerCamelCase_     )
            for image in image_inputs:
                 self.assertIsInstance(lowerCamelCase_   ,				Image.Image     )

            # Test not batched input
            a_     :  Dict				      =     image_processing(image_inputs[0]   ,				return_tensors="""pt"""     ).pixel_values
            self.assertEqual(
                encoded_images.shape   ,				(
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size["""height"""],
                    self.image_processor_tester.crop_size["""width"""],
                )   ,				)

            # Test batched
            a_     :  Any				      =     image_processing(lowerCamelCase_   ,				return_tensors="""pt"""     ).pixel_values
            self.assertEqual(
                encoded_images.shape   ,				(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size["""height"""],
                    self.image_processor_tester.crop_size["""width"""],
                )   ,				)

       def     UpperCAmelCase( self   :  Optional[int]     ):
            # Initialize image_processing
            a_     :  int				      =     self.image_processing_class(**self.image_processor_dict     )
            # create random numpy tensors
            a_     :  Union[str, Any]				      =     prepare_image_inputs(self.image_processor_tester   ,				equal_resolution=lowerCamelCase_   ,				numpify=lowerCamelCase_     )
            for image in image_inputs:
                 self.assertIsInstance(lowerCamelCase_   ,				np.ndarray     )

            # Test not batched input
            a_     :  Union[str, Any]				      =     image_processing(image_inputs[0]   ,				return_tensors="""pt"""     ).pixel_values
            self.assertEqual(
                encoded_images.shape   ,				(
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size["""height"""],
                    self.image_processor_tester.crop_size["""width"""],
                )   ,				)

            # Test batched
            a_     :  Tuple				      =     image_processing(lowerCamelCase_   ,				return_tensors="""pt"""     ).pixel_values
            self.assertEqual(
                encoded_images.shape   ,				(
                    self.image_processor_tester.batch_size,
                    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]     ):
            # Initialize image_processing
            a_     :  Optional[Any]				      =     self.image_processing_class(**self.image_processor_dict     )
            # create random PyTorch tensors
            a_     :  str				      =     prepare_image_inputs(self.image_processor_tester   ,				equal_resolution=lowerCamelCase_   ,				torchify=lowerCamelCase_     )
            for image in image_inputs:
                 self.assertIsInstance(lowerCamelCase_   ,				torch.Tensor     )

            # Test not batched input
            a_     :  List[str]				      =     image_processing(image_inputs[0]   ,				return_tensors="""pt"""     ).pixel_values
            self.assertEqual(
                encoded_images.shape   ,				(
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size["""height"""],
                    self.image_processor_tester.crop_size["""width"""],
                )   ,				)

            # Test batched
            a_     :  int				      =     image_processing(lowerCamelCase_   ,				return_tensors="""pt"""     ).pixel_values
            self.assertEqual(
                encoded_images.shape   ,				(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size["""height"""],
                    self.image_processor_tester.crop_size["""width"""],
                )   ,				)





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_				:							Optional[Any]       =    logging.get_logger(__name__)

if is_tf_available():
 import tensorflow as tf







@dataclass
class  _lowerCamelCase			(lowerCamelCase					):
     lowercase__				  =			"""tf"""
     lowercase__				  =			field(
         default=lowerCamelCase							,					metadata={"""help""": """Name of TPU"""}							,					)

     lowercase__				  =			field(
         default=lowerCamelCase							,					metadata={"""help""": """Zone of TPU"""}							,					)

     lowercase__				  =			field(
         default=lowerCamelCase							,					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=lowerCamelCase							,					metadata={"""help""": """Whether to activate the XLA compilation or not"""}					)

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

            __snake_case						       =   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:
                   __snake_case						       =   tf.distribute.OneDeviceStrategy(device='/cpu:0'    )
            else:
                   try:
                          if self.tpu_name:
                                 __snake_case						       =   tf.distribute.cluster_resolver.TPUClusterResolver(
                                     self.tpu_name							,       zone=self.tpu_zone							,       project=self.gcp_project    )
                          else:
                                 __snake_case						       =   tf.distribute.cluster_resolver.TPUClusterResolver()
                   except ValueError:
                          if self.tpu_name:
                                 raise RuntimeError(f'''Couldn\'t connect to TPU {self.tpu_name}!'''    )
                          else:
                                 __snake_case						       =   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(SCREAMING_SNAKE_CASE_    )
                          tf.tpu.experimental.initialize_tpu_system(SCREAMING_SNAKE_CASE_    )

                          __snake_case						       =   tf.distribute.TPUStrategy(SCREAMING_SNAKE_CASE_    )

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

            return strategy

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

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

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

     @property
     def 						__lowerCamelCase				(  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.'    )
            __snake_case						       =   self.per_gpu_train_batch_size or self.per_device_train_batch_size
            return per_device_batch_size * self.n_replicas

     @property
     def 						__lowerCamelCase				(  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.'    )
            __snake_case						       =   self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
            return per_device_batch_size * self.n_replicas

     @property
     def 						__lowerCamelCase				(  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.'							,       SCREAMING_SNAKE_CASE_							,       )
            return self._setup_strategy.num_replicas_in_sync
