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


if is_torch_available():
      import torch

if is_vision_available():
      from PIL import Image

      from transformers import OwlViTImageProcessor




class    lowerCamelCase__  (   unittest.TestCase     ):



   def __init__(    self					,      lowerCAmelCase__					,      lowerCAmelCase__=7					,      lowerCAmelCase__=3					,      lowerCAmelCase__=18					,      lowerCAmelCase__=30					,      lowerCAmelCase__=400					,      lowerCAmelCase__=True					,      lowerCAmelCase__=None					,      lowerCAmelCase__=True					,      lowerCAmelCase__=None					,      lowerCAmelCase__=True					,      lowerCAmelCase__=[0.4814_5466, 0.457_8275, 0.4082_1073]					,      lowerCAmelCase__=[0.2686_2954, 0.2613_0258, 0.2757_7711]					,      lowerCAmelCase__=True					,      )				->     Optional[int]:
        """simple docstring"""





        _UpperCamelCase  :List[str]       =parent
        _UpperCamelCase  :Optional[Any]       =batch_size
        _UpperCamelCase  :Any       =num_channels
        _UpperCamelCase  :int       =image_size
        _UpperCamelCase  :Optional[Any]       =min_resolution
        _UpperCamelCase  :int       =max_resolution
        _UpperCamelCase  :List[Any]       =do_resize
        _UpperCamelCase  :Any       =size if size is not None else {"""height""": 18, """width""": 18}
        _UpperCamelCase  :Dict       =do_center_crop
        _UpperCamelCase  :List[str]       =crop_size if crop_size is not None else {"""height""": 18, """width""": 18}
        _UpperCamelCase  :Any       =do_normalize
        _UpperCamelCase  :Any       =image_mean
        _UpperCamelCase  :str       =image_std
        _UpperCamelCase  :str       =do_convert_rgb




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





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




@require_torch
@require_vision
class    lowerCamelCase__  (   __snake_case       ,				unittest.TestCase     ):
   __UpperCAmelCase           =						OwlViTImageProcessor if is_vision_available() else None



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





        _UpperCamelCase  :Union[str, Any]       =OwlViTImageProcessingTester(self     )



   @property
   def  _UpperCamelCase		(    self     )				->     Any:
        """simple docstring"""





        return self.image_processor_tester.prepare_image_processor_dict()



   def  _UpperCamelCase		(    self     )				->     int:
        """simple docstring"""





        _UpperCamelCase  :List[Any]       =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"""     )     )
        self.assertTrue(hasattr(lowerCAmelCase__					,      """do_normalize"""     )     )
        self.assertTrue(hasattr(lowerCAmelCase__					,      """image_mean"""     )     )
        self.assertTrue(hasattr(lowerCAmelCase__					,      """image_std"""     )     )
        self.assertTrue(hasattr(lowerCAmelCase__					,      """do_convert_rgb"""     )     )



   def  _UpperCamelCase		(    self     )				->     Tuple:
        """simple docstring"""





        _UpperCamelCase  :Any       =self.image_processing_class.from_dict(self.image_processor_dict     )
        self.assertEqual(image_processor.size					,      {"""height""": 18, """width""": 18}     )
        self.assertEqual(image_processor.crop_size					,      {"""height""": 18, """width""": 18}     )

        _UpperCamelCase  :str       =self.image_processing_class.from_dict(self.image_processor_dict					,      size=42					,      crop_size=84     )
        self.assertEqual(image_processor.size					,      {"""height""": 42, """width""": 42}     )
        self.assertEqual(image_processor.crop_size					,      {"""height""": 84, """width""": 84}     )



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





        _UpperCamelCase  :Union[str, Any]       =self.image_processing_class(**self.image_processor_dict     )
        # create random PIL images
        _UpperCamelCase  :List[str]       =prepare_image_inputs(self.image_processor_tester					,      equal_resolution=lowerCAmelCase__     )

        for image in image_inputs:
             self.assertIsInstance(lowerCAmelCase__					,      Image.Image     )

        # Test not batched input
        _UpperCamelCase  :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
        _UpperCamelCase  :List[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     )				->     str:
        """simple docstring"""





        _UpperCamelCase  :List[str]       =self.image_processing_class(**self.image_processor_dict     )
        # create random numpy tensors
        _UpperCamelCase  :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
        _UpperCamelCase  :Optional[int]       =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
        _UpperCamelCase  :str       =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     )				->     List[str]:
        """simple docstring"""





        _UpperCamelCase  :List[str]       =self.image_processing_class(**self.image_processor_dict     )
        # create random PyTorch tensors
        _UpperCamelCase  :Dict       =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
        _UpperCamelCase  :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
        _UpperCamelCase  :Dict       =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"""],
            )					,      )


"""simple docstring"""






import timeit
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_auto import MODEL_MAPPING, MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_torch_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_torch_available():
							import torch

							from .benchmark_args import PyTorchBenchmarkArguments


if is_pyanvml_available():
							import pyanvml.pyanvml as nvml


__lowerCAmelCase				      =   logging.get_logger(__name__)
class 	_lowerCAmelCase    (      __snake_case       ):
							__lowerCAmelCase					:    PyTorchBenchmarkArguments
							__lowerCAmelCase					:    PretrainedConfig
							__lowerCAmelCase					:    str     =  "PyTorch"

							@property
							def 					_lowerCAmelCase  ( self       :    Dict    )   ->    Dict:

									"""simple docstring"""
									return torch.__version__

							def 					_lowerCAmelCase  ( self       :    List[Any] ,		a       :    str ,		a       :    int ,		a       :    int    )   ->    float:

									"""simple docstring"""
									lowercase										=							self._prepare_inference_func(a ,		a ,		a    )
									return self._measure_speed(_inference    )

							def 					_lowerCAmelCase  ( self       :    str ,		a       :    str ,		a       :    int ,		a       :    int    )   ->    [Memory, Optional[MemorySummary]]:

									"""simple docstring"""
									lowercase										=							self._prepare_inference_func(a ,		a ,		a    )
									return self._measure_memory(_inference    )

							def 					_lowerCAmelCase  ( self       :    Union[str, Any] ,		a       :    str ,		a       :    int ,		a       :    int    )   ->    float:

									"""simple docstring"""
									lowercase										=							self._prepare_train_func(a ,		a ,		a    )
									return self._measure_speed(_train    )

							def 					_lowerCAmelCase  ( self       :    int ,		a       :    str ,		a       :    int ,		a       :    int    )   ->    [Memory, Optional[MemorySummary]]:

									"""simple docstring"""
									lowercase										=							self._prepare_train_func(a ,		a ,		a    )
									return self._measure_memory(_train    )

							def 					_lowerCAmelCase  ( self       :    List[Any] ,		a       :    str ,		a       :    int ,		a       :    int    )   ->    Callable[[], None]:

									"""simple docstring"""
									lowercase										=							self.config_dict[model_name]

									if self.args.torchscript:
											lowercase										=							True

									lowercase										=							(
									    hasattr(a ,		'''architectures'''    )
									    and isinstance(config.architectures ,		a    )
									    and len(config.architectures    ) > 0
									)
									if not self.args.only_pretrain_model and has_model_class_in_config:
											try:
													lowercase										=							config.architectures[0]
													lowercase										=							__import__('''transformers''' ,		fromlist=[model_class]    )
													lowercase										=							getattr(a ,		a    )
													lowercase										=							model_cls(a    )
											except ImportError:
													raise ImportError(
													    f"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
													    ''' set `--only_pretrain_model` or `args.only_pretrain_model=True`.'''    )
									else:
											lowercase										=							MODEL_MAPPING[config.__class__](a    )

									model.eval()
									model.to(self.args.device    )

									# encoder-decoder has vocab size saved differently
									lowercase										=							config.vocab_size if hasattr(a ,		'''vocab_size'''    ) else config.encoder.vocab_size
									lowercase										=							torch.randint(a ,		(batch_size, sequence_length) ,		dtype=torch.long ,		device=self.args.device    )

									if self.args.fpaa:
											logger.info('''Running training in Mixed Precision...'''    )
											if not self.args.is_gpu:
													raise ValueError('''Mixed precision is possible only for GPU.'''    )
											# amp seems to have memory leaks so that memory usage
											# is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
											model.half()

									if self.args.torchscript:
											with torch.no_grad():
													lowercase										=							torch.jit.trace(a ,		a    )
									else:
											lowercase										=							model

									def encoder_decoder_forward():
											with torch.no_grad():
													lowercase										=							inference_model(a ,		decoder_input_ids=a    )
											return outputs

									def encoder_forward():
											with torch.no_grad():
													lowercase										=							inference_model(a    )
											return outputs

									lowercase										=							encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
									return _forward

							def 					_lowerCAmelCase  ( self       :    int ,		a       :    str ,		a       :    int ,		a       :    int    )   ->    Callable[[], None]:

									"""simple docstring"""
									lowercase										=							self.config_dict[model_name]

									lowercase										=							(
									    hasattr(a ,		'''architectures'''    )
									    and isinstance(config.architectures ,		a    )
									    and len(config.architectures    ) > 0
									)
									if not self.args.only_pretrain_model and has_model_class_in_config:
											try:
													lowercase										=							config.architectures[0]
													lowercase										=							__import__('''transformers''' ,		fromlist=[model_class]    )
													lowercase										=							getattr(a ,		a    )
													lowercase										=							model_cls(a    )
											except ImportError:
													raise ImportError(
													    f"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
													    ''' set `--only_pretrain_model` or `args.only_pretrain_model=True`.'''    )
									else:
											lowercase										=							MODEL_WITH_LM_HEAD_MAPPING[config.__class__](a    )

									if self.args.torchscript:
											raise NotImplementedError('''Training for torchscript is currently not implemented'''    )
									else:
											lowercase										=							model

									model.train()
									model.to(self.args.device    )

									# encoder-decoder has vocab size saved differently
									lowercase										=							config.vocab_size if hasattr(a ,		'''vocab_size'''    ) else config.encoder.vocab_size
									lowercase										=							torch.randint(a ,		(batch_size, sequence_length) ,		dtype=torch.long ,		device=self.args.device    )

									if self.args.fpaa:
											logger.info('''Running training in Mixed Precision...'''    )
											if not self.args.is_gpu:
													raise ValueError('''Mixed precision is possible only for GPU.'''    )

											# amp seems to have memory leaks so that memory usage
											# is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
											model.half()

									def compute_loss_and_backprob_encoder():
											lowercase										=							train_model(a ,		labels=a    )[0]
											loss.backward()
											return loss

									def compute_loss_and_backprob_encoder_decoder():
											lowercase										=							train_model(a ,		decoder_input_ids=a ,		labels=a    )[0]
											loss.backward()
											return loss

									lowercase										=							(
									    compute_loss_and_backprob_encoder_decoder
									    if config.is_encoder_decoder
									    else compute_loss_and_backprob_encoder
									)
									return _train

							def 					_lowerCAmelCase  ( self       :    int ,		a       :    Optional[Any]    )   ->    float:

									"""simple docstring"""
									try:
											if self.args.is_tpu or self.args.torchscript:
													# run additional 10 times to stabilize compilation for tpu and torchscript
													logger.info('''Do inference on TPU or torchscript. Running model 5 times to stabilize compilation'''    )
													timeit.repeat(
													    a ,		repeat=1 ,		number=5 ,		)

											# as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
											lowercase										=							timeit.repeat(
											    a ,		repeat=self.args.repeat ,		number=10 ,		)

											if self.args.is_tpu and self.args.torch_xla_tpu_print_metrics:
													import torch_xla.debug.metrics as met

													self.print_fn(met.metrics_report()    )

											return min(a    ) / 10.0
									except RuntimeError as e:
											self.print_fn(f"""Doesn't fit on GPU. {e}"""    )
											return "N/A"

							def 					_lowerCAmelCase  ( self       :    str ,		a       :    Callable[[], None]    )   ->    [Memory, MemorySummary]:

									"""simple docstring"""
									try:
											if self.args.trace_memory_line_by_line:
													lowercase										=							start_memory_tracing('''transformers'''    )

											if self.args.is_tpu:
													# tpu
													raise NotImplementedError(
													    '''Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking with'''
													    ''' `--no-memory` or `args.memory=False`'''    )
											elif self.args.is_gpu:
													if not is_pyanvml_available():
															logger.warning(
															    '''py3nvml not installed, we won\'t log GPU memory usage. '''
															    '''Install py3nvml (pip install py3nvml) to log information about GPU.'''    )
															lowercase										=							'''N/A'''
													else:
															logger.info(
															    '''Measuring total GPU usage on GPU device. Make sure to not have additional processes running'''
															    ''' on the same GPU.'''    )
															# init nvml
															nvml.nvmlInit()
															func()
															lowercase										=							nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx    )
															lowercase										=							nvml.nvmlDeviceGetMemoryInfo(a    )
															lowercase										=							meminfo.used
															lowercase										=							Memory(a    )
															# shutdown nvml
															nvml.nvmlShutdown()
											else:
													# cpu
													lowercase										=							measure_peak_memory_cpu(a    )
													lowercase										=							Memory(a    ) if isinstance(a ,		a    ) else memory_bytes

											if self.args.trace_memory_line_by_line:
													lowercase										=							stop_memory_tracing(a    )
											else:
													lowercase										=							None

											return memory, summary
									except RuntimeError as e:
											self.print_fn(f"""Doesn't fit on GPU. {e}"""    )
											return "N/A", None