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


UpperCAmelCase            = logging.get_logger(__name__)

class     a (					__magic_name__     ):
				_snake_case		     =			42
				_snake_case		     =			42
				_snake_case		     =			'''PyTorch'''




				@property
				def 						__snake_case				(				self						:					Optional[int]   ):
										return torch.__version__




				def 						__snake_case				(				self						:					Optional[int],     SCREAMING_SNAKE_CASE_						:					str,     SCREAMING_SNAKE_CASE_						:					int,     SCREAMING_SNAKE_CASE_						:					int   ):
										snake_case							:  Any			=     self._prepare_inference_func(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_   )
										return self._measure_speed(_inference   )




				def 						__snake_case				(				self						:					List[Any],     SCREAMING_SNAKE_CASE_						:					Dict,     SCREAMING_SNAKE_CASE_						:					List[Any],     SCREAMING_SNAKE_CASE_						:					str   ):
										snake_case							:  Dict			=     self._prepare_inference_func(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_   )
										return self._measure_memory(_inference   )




				def 						__snake_case				(				self						:					Optional[int],     SCREAMING_SNAKE_CASE_						:					str,     SCREAMING_SNAKE_CASE_						:					List[Any],     SCREAMING_SNAKE_CASE_						:					Tuple   ):
										snake_case							:  Optional[Any]			=     self._prepare_train_func(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_   )
										return self._measure_speed(_train   )




				def 						__snake_case				(				self						:					int,     SCREAMING_SNAKE_CASE_						:					List[Any],     SCREAMING_SNAKE_CASE_						:					int,     SCREAMING_SNAKE_CASE_						:					str   ):
										snake_case							:  Optional[int]			=     self._prepare_train_func(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_   )
										return self._measure_memory(_train   )




				def 						__snake_case				(				self						:					List[str],     SCREAMING_SNAKE_CASE_						:					Union[str, Any],     SCREAMING_SNAKE_CASE_						:					Any,     SCREAMING_SNAKE_CASE_						:					Optional[int]   ):
										snake_case							:  str			=     self.config_dict[model_name]

										if self.args.torchscript:
																snake_case							:  Tuple			=     True

										snake_case							:  Union[str, Any]			=     (
										    hasattr(SCREAMING_SNAKE_CASE_,     '''architectures'''   )
										    and isinstance(config.architectures,     SCREAMING_SNAKE_CASE_   )
										    and len(config.architectures   ) > 0
										)
										if not self.args.only_pretrain_model and has_model_class_in_config:
																try:
																						snake_case							:  Dict			=     config.architectures[0]
																						snake_case							:  List[str]			=     __import__('''transformers''',     fromlist=[model_class]   )
																						snake_case							:  Tuple			=     getattr(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_   )
																						snake_case							:  Dict			=     model_cls(SCREAMING_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:
																snake_case							:  List[Any]			=     MODEL_MAPPING[config.__class__](SCREAMING_SNAKE_CASE_   )

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

										# encoder-decoder has vocab size saved differently
										snake_case							:  List[str]			=     config.vocab_size if hasattr(SCREAMING_SNAKE_CASE_,     '''vocab_size'''   ) else config.encoder.vocab_size
										snake_case							:  Optional[Any]			=     torch.randint(SCREAMING_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():
																						snake_case							:  List[Any]			=     torch.jit.trace(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_   )
										else:
																snake_case							:  str			=     model

										def encoder_decoder_forward():
																with torch.no_grad():
																						snake_case							:  str			=     inference_model(SCREAMING_SNAKE_CASE_,     decoder_input_ids=SCREAMING_SNAKE_CASE_   )
																return outputs

										def encoder_forward():
																with torch.no_grad():
																						snake_case							:  str			=     inference_model(SCREAMING_SNAKE_CASE_   )
																return outputs

										snake_case							:  Optional[Any]			=     encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
										return _forward




				def 						__snake_case				(				self						:					Union[str, Any],     SCREAMING_SNAKE_CASE_						:					Union[str, Any],     SCREAMING_SNAKE_CASE_						:					Dict,     SCREAMING_SNAKE_CASE_						:					List[str]   ):
										snake_case							:  int			=     self.config_dict[model_name]

										snake_case							:  Optional[int]			=     (
										    hasattr(SCREAMING_SNAKE_CASE_,     '''architectures'''   )
										    and isinstance(config.architectures,     SCREAMING_SNAKE_CASE_   )
										    and len(config.architectures   ) > 0
										)
										if not self.args.only_pretrain_model and has_model_class_in_config:
																try:
																						snake_case							:  List[Any]			=     config.architectures[0]
																						snake_case							:  List[str]			=     __import__('''transformers''',     fromlist=[model_class]   )
																						snake_case							:  Tuple			=     getattr(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_   )
																						snake_case							:  Any			=     model_cls(SCREAMING_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:
																snake_case							:  List[str]			=     MODEL_WITH_LM_HEAD_MAPPING[config.__class__](SCREAMING_SNAKE_CASE_   )

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

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

										# encoder-decoder has vocab size saved differently
										snake_case							:  Tuple			=     config.vocab_size if hasattr(SCREAMING_SNAKE_CASE_,     '''vocab_size'''   ) else config.encoder.vocab_size
										snake_case							:  Optional[int]			=     torch.randint(SCREAMING_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():
																snake_case							:  List[str]			=     train_model(SCREAMING_SNAKE_CASE_,     labels=SCREAMING_SNAKE_CASE_   )[0]
																loss.backward()
																return loss

										def compute_loss_and_backprob_encoder_decoder():
																snake_case							:  List[Any]			=     train_model(SCREAMING_SNAKE_CASE_,     decoder_input_ids=SCREAMING_SNAKE_CASE_,     labels=SCREAMING_SNAKE_CASE_   )[0]
																loss.backward()
																return loss

										snake_case							:  Dict			=     (
										    compute_loss_and_backprob_encoder_decoder
										    if config.is_encoder_decoder
										    else compute_loss_and_backprob_encoder
										)
										return _train




				def 						__snake_case				(				self						:					Dict,     SCREAMING_SNAKE_CASE_						:					Dict   ):
										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(
																						    SCREAMING_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
																snake_case							:  Tuple			=     timeit.repeat(
																    SCREAMING_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(SCREAMING_SNAKE_CASE_   ) / 10.0
										except RuntimeError as e:
																self.print_fn(F"""Doesn't fit on GPU. {e}"""   )
																return "N/A"




				def 						__snake_case				(				self						:					Dict,     SCREAMING_SNAKE_CASE_						:					Tuple   ):
										try:
																if self.args.trace_memory_line_by_line:
																						snake_case							:  Tuple			=     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.'''   )
																												snake_case							:  Union[str, Any]			=     '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()
																												snake_case							:  int			=     nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx   )
																												snake_case							:  List[str]			=     nvml.nvmlDeviceGetMemoryInfo(SCREAMING_SNAKE_CASE_   )
																												snake_case							:  Tuple			=     meminfo.used
																												snake_case							:  Dict			=     Memory(SCREAMING_SNAKE_CASE_   )
																												# shutdown nvml
																												nvml.nvmlShutdown()
																else:
																						# cpu
																						snake_case							:  Tuple			=     measure_peak_memory_cpu(SCREAMING_SNAKE_CASE_   )
																						snake_case							:  str			=     Memory(SCREAMING_SNAKE_CASE_   ) if isinstance(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_   ) else memory_bytes

																if self.args.trace_memory_line_by_line:
																						snake_case							:  int			=     stop_memory_tracing(SCREAMING_SNAKE_CASE_   )
																else:
																						snake_case							:  Any			=     None

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








'''simple docstring'''


from __future__ import annotations

from collections.abc import Callable




def       A							(      _UpperCAmelCase   :				Callable[[int | float], int | float]						,_UpperCAmelCase   :				int | float						,_UpperCAmelCase   :				int | float						,_UpperCAmelCase   :				int = 1_0_0						,)  ->				float:


  '''simple docstring'''




  __lowerCAmelCase		:    Dict			     =  x_start
  __lowerCAmelCase		:    Tuple			     =  fnc(_UpperCAmelCase					)
  __lowerCAmelCase		:    Optional[int]			     =  0.0

  for _ in range(_UpperCAmelCase					):
    # Approximates small segments of curve as linear and solve
    # for trapezoidal area
    __lowerCAmelCase		:    Optional[int]			     =  (x_end - x_start) / steps + xa
    __lowerCAmelCase		:    Optional[Any]			     =  fnc(_UpperCAmelCase					)
    area += abs(fxa + fxa					) * (xa - xa) / 2

    # Increment step
    __lowerCAmelCase		:    Optional[Any]			     =  xa
    __lowerCAmelCase		:    List[Any]			     =  fxa
  return area


if __name__ == "__main__":




    def       A							(      _UpperCAmelCase   :				List[Any]					)  ->				List[Any]:


      '''simple docstring'''




      return x**3

    print("f(x) = x^3")
    print("The area between the curve, x = -10, x = 10 and the x axis is:")
    A_				     =							10
    while i <= 10_00_00:
        A_				     =							trapezoidal_area(f, -5, 5, i)
        print(F'''with {i} steps: {area}''')
        i *= 10





