






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





class      UpperCamelCase_       (				a_     ):
  _A				:    PyTorchBenchmarkArguments
  _A				:    PretrainedConfig
  _A				:    str =		"PyTorch"



  @property
  def 						UpperCamelCase_ (					self )	->	str:



         """simple docstring"""





         return torch.__version__



  def 						UpperCamelCase_ (					self       ,						snake_case__       ,						snake_case__       ,						snake_case__ )	->	float:



         """simple docstring"""





         UpperCAmelCase					=	self._prepare_inference_func(snake_case__       ,						snake_case__       ,						snake_case__ )
         return self._measure_speed(_inference )



  def 						UpperCamelCase_ (					self       ,						snake_case__       ,						snake_case__       ,						snake_case__ )	->	[Memory, Optional[MemorySummary]]:



         """simple docstring"""





         UpperCAmelCase					=	self._prepare_inference_func(snake_case__       ,						snake_case__       ,						snake_case__ )
         return self._measure_memory(_inference )



  def 						UpperCamelCase_ (					self       ,						snake_case__       ,						snake_case__       ,						snake_case__ )	->	float:



         """simple docstring"""





         UpperCAmelCase					=	self._prepare_train_func(snake_case__       ,						snake_case__       ,						snake_case__ )
         return self._measure_speed(_train )



  def 						UpperCamelCase_ (					self       ,						snake_case__       ,						snake_case__       ,						snake_case__ )	->	[Memory, Optional[MemorySummary]]:



         """simple docstring"""





         UpperCAmelCase					=	self._prepare_train_func(snake_case__       ,						snake_case__       ,						snake_case__ )
         return self._measure_memory(_train )



  def 						UpperCamelCase_ (					self       ,						snake_case__       ,						snake_case__       ,						snake_case__ )	->	Callable[[], None]:



         """simple docstring"""





         UpperCAmelCase					=	self.config_dict[model_name]

         if self.args.torchscript:
                UpperCAmelCase					=	True

         UpperCAmelCase					=	(
             hasattr(snake_case__       ,						"""architectures""" )
             and isinstance(config.architectures       ,						snake_case__ )
             and len(config.architectures ) > 0
         )
         if not self.args.only_pretrain_model and has_model_class_in_config:
                try:
                       UpperCAmelCase					=	config.architectures[0]
                       UpperCAmelCase					=	__import__("""transformers"""       ,						fromlist=[model_class] )
                       UpperCAmelCase					=	getattr(snake_case__       ,						snake_case__ )
                       UpperCAmelCase					=	model_cls(snake_case__ )
                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:
                UpperCAmelCase					=	MODEL_MAPPING[config.__class__](snake_case__ )

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

         # encoder-decoder has vocab size saved differently
         UpperCAmelCase					=	config.vocab_size if hasattr(snake_case__       ,						"""vocab_size""" ) else config.encoder.vocab_size
         UpperCAmelCase					=	torch.randint(snake_case__       ,						(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():
                       UpperCAmelCase					=	torch.jit.trace(snake_case__       ,						snake_case__ )
         else:
                UpperCAmelCase					=	model

         def encoder_decoder_forward():
                with torch.no_grad():
                       UpperCAmelCase					=	inference_model(snake_case__       ,						decoder_input_ids=snake_case__ )
                return outputs

         def encoder_forward():
                with torch.no_grad():
                       UpperCAmelCase					=	inference_model(snake_case__ )
                return outputs

         UpperCAmelCase					=	encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
         return _forward



  def 						UpperCamelCase_ (					self       ,						snake_case__       ,						snake_case__       ,						snake_case__ )	->	Callable[[], None]:



         """simple docstring"""





         UpperCAmelCase					=	self.config_dict[model_name]

         UpperCAmelCase					=	(
             hasattr(snake_case__       ,						"""architectures""" )
             and isinstance(config.architectures       ,						snake_case__ )
             and len(config.architectures ) > 0
         )
         if not self.args.only_pretrain_model and has_model_class_in_config:
                try:
                       UpperCAmelCase					=	config.architectures[0]
                       UpperCAmelCase					=	__import__("""transformers"""       ,						fromlist=[model_class] )
                       UpperCAmelCase					=	getattr(snake_case__       ,						snake_case__ )
                       UpperCAmelCase					=	model_cls(snake_case__ )
                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:
                UpperCAmelCase					=	MODEL_WITH_LM_HEAD_MAPPING[config.__class__](snake_case__ )

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

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

         # encoder-decoder has vocab size saved differently
         UpperCAmelCase					=	config.vocab_size if hasattr(snake_case__       ,						"""vocab_size""" ) else config.encoder.vocab_size
         UpperCAmelCase					=	torch.randint(snake_case__       ,						(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():
                UpperCAmelCase					=	train_model(snake_case__       ,						labels=snake_case__ )[0]
                loss.backward()
                return loss

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

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



  def 						UpperCamelCase_ (					self       ,						snake_case__ )	->	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(
                           snake_case__       ,						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
                UpperCAmelCase					=	timeit.repeat(
                    snake_case__       ,						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(snake_case__ ) / 10.0
         except RuntimeError as e:
                self.print_fn(f'''Doesn\'t fit on GPU. {e}''' )
                return "N/A"



  def 						UpperCamelCase_ (					self       ,						snake_case__ )	->	[Memory, MemorySummary]:



         """simple docstring"""





         try:
                if self.args.trace_memory_line_by_line:
                       UpperCAmelCase					=	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.""" )
                              UpperCAmelCase					=	"""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()
                              UpperCAmelCase					=	nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx )
                              UpperCAmelCase					=	nvml.nvmlDeviceGetMemoryInfo(snake_case__ )
                              UpperCAmelCase					=	meminfo.used
                              UpperCAmelCase					=	Memory(snake_case__ )
                              # shutdown nvml
                              nvml.nvmlShutdown()
                else:
                       # cpu
                       UpperCAmelCase					=	measure_peak_memory_cpu(snake_case__ )
                       UpperCAmelCase					=	Memory(snake_case__ ) if isinstance(snake_case__       ,						snake_case__ ) else memory_bytes

                if self.args.trace_memory_line_by_line:
                       UpperCAmelCase					=	stop_memory_tracing(snake_case__ )
                else:
                       UpperCAmelCase					=	None

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







from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


UpperCAmelCase__  :	Dict     =logging.get_logger(__name__)


if is_vision_available():
							import PIL

class 					__A   (  a			):
				__A            = ["""pixel_values"""]


				def __init__(						self      ,       UpperCAmelCase_ = True      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = PILImageResampling.BICUBIC      ,       UpperCAmelCase_ = True      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = True      ,       UpperCAmelCase_ = 1 / 255      ,       UpperCAmelCase_ = True      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = True      ,       **UpperCAmelCase_      ,       ):
								super().__init__(**UpperCAmelCase_							)
								lowerCamelCase		       =size if size is not None else {"""shortest_edge""": 224}
								lowerCamelCase		       =get_size_dict(UpperCAmelCase_      ,       default_to_square=UpperCAmelCase_							)
								lowerCamelCase		       =crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
								lowerCamelCase		       =get_size_dict(UpperCAmelCase_							)

								lowerCamelCase		       =do_resize
								lowerCamelCase		       =size
								lowerCamelCase		       =resample
								lowerCamelCase		       =do_center_crop
								lowerCamelCase		       =crop_size
								lowerCamelCase		       =do_rescale
								lowerCamelCase		       =rescale_factor
								lowerCamelCase		       =do_normalize
								lowerCamelCase		       =image_mean if image_mean is not None else OPENAI_CLIP_MEAN
								lowerCamelCase		       =image_std if image_std is not None else OPENAI_CLIP_STD
								lowerCamelCase		       =do_convert_rgb


				def _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_ = PILImageResampling.BICUBIC      ,       UpperCAmelCase_ = None      ,       **UpperCAmelCase_      ,       ):
								lowerCamelCase		       =get_size_dict(UpperCAmelCase_      ,       default_to_square=UpperCAmelCase_							)
								lowerCamelCase		       =get_resize_output_image_size(
								    UpperCAmelCase_      ,       size=(size["""height"""], size["""width"""])      ,       default_to_square=UpperCAmelCase_							)
								return resize(UpperCAmelCase_      ,       size=UpperCAmelCase_      ,       resample=UpperCAmelCase_      ,       data_format=UpperCAmelCase_      ,       **UpperCAmelCase_							)


				def _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_ = None      ,       **UpperCAmelCase_      ,       ):
								lowerCamelCase		       =get_size_dict(UpperCAmelCase_							)
								return center_crop(UpperCAmelCase_      ,       size=(size["""height"""], size["""width"""])      ,       data_format=UpperCAmelCase_      ,       **UpperCAmelCase_							)


				def _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_ = None      ,       **UpperCAmelCase_      ,       ):
								return rescale(UpperCAmelCase_      ,       scale=UpperCAmelCase_      ,       data_format=UpperCAmelCase_      ,       **UpperCAmelCase_							)


				def _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_ = None      ,       **UpperCAmelCase_      ,       ):
								return normalize(UpperCAmelCase_      ,       mean=UpperCAmelCase_      ,       std=UpperCAmelCase_      ,       data_format=UpperCAmelCase_      ,       **UpperCAmelCase_							)


				def _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = None      ,       UpperCAmelCase_ = ChannelDimension.FIRST      ,       **UpperCAmelCase_      ,       ):
								lowerCamelCase		       =do_resize if do_resize is not None else self.do_resize
								lowerCamelCase		       =size if size is not None else self.size
								lowerCamelCase		       =get_size_dict(UpperCAmelCase_      ,       default_to_square=UpperCAmelCase_							)
								lowerCamelCase		       =resample if resample is not None else self.resample
								lowerCamelCase		       =do_center_crop if do_center_crop is not None else self.do_center_crop
								lowerCamelCase		       =crop_size if crop_size is not None else self.crop_size
								lowerCamelCase		       =get_size_dict(UpperCAmelCase_							)
								lowerCamelCase		       =do_rescale if do_rescale is not None else self.do_rescale
								lowerCamelCase		       =rescale_factor if rescale_factor is not None else self.rescale_factor
								lowerCamelCase		       =do_normalize if do_normalize is not None else self.do_normalize
								lowerCamelCase		       =image_mean if image_mean is not None else self.image_mean
								lowerCamelCase		       =image_std if image_std is not None else self.image_std
								lowerCamelCase		       =do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

								lowerCamelCase		       =make_list_of_images(UpperCAmelCase_							)

								if not valid_images(UpperCAmelCase_							):
												raise ValueError(
												    """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
												    """torch.Tensor, tf.Tensor or jax.ndarray."""							)

								if do_resize and size is None:
												raise ValueError("""Size must be specified if do_resize is True."""							)

								if do_center_crop and crop_size is None:
												raise ValueError("""Crop size must be specified if do_center_crop is True."""							)

								if do_rescale and rescale_factor is None:
												raise ValueError("""Rescale factor must be specified if do_rescale is True."""							)

								if do_normalize and (image_mean is None or image_std is None):
												raise ValueError("""Image mean and std must be specified if do_normalize is True."""							)

								# PIL RGBA images are converted to RGB
								if do_convert_rgb:
												lowerCamelCase		       =[convert_to_rgb(UpperCAmelCase_							) for image in images]

								# All transformations expect numpy arrays.
								lowerCamelCase		       =[to_numpy_array(UpperCAmelCase_							) for image in images]

								if do_resize:
												lowerCamelCase		       =[self.resize(image=UpperCAmelCase_      ,       size=UpperCAmelCase_      ,       resample=UpperCAmelCase_							) for image in images]

								if do_center_crop:
												lowerCamelCase		       =[self.center_crop(image=UpperCAmelCase_      ,       size=UpperCAmelCase_							) for image in images]

								if do_rescale:
												lowerCamelCase		       =[self.rescale(image=UpperCAmelCase_      ,       scale=UpperCAmelCase_							) for image in images]

								if do_normalize:
												lowerCamelCase		       =[self.normalize(image=UpperCAmelCase_      ,       mean=UpperCAmelCase_      ,       std=UpperCAmelCase_							) for image in images]

								lowerCamelCase		       =[to_channel_dimension_format(UpperCAmelCase_      ,       UpperCAmelCase_							) for image in images]

								lowerCamelCase		       ={"""pixel_values""": images}
								return BatchFeature(data=UpperCAmelCase_      ,       tensor_type=UpperCAmelCase_							)





