code: 
  
  
  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 			a      (      UpperCamelCase_   ):
  		__lowercase													=		42
  		__lowercase													=		42
  		__lowercase													=		"PyTorch"
  
  
  
  
  
  
  		@property
  		def       lowerCAmelCase_  (  self							)->			Optional[int]:
  						'''simple docstring'''
  
  
  						return torch.__version__
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)->			float:
  						'''simple docstring'''
  
  
  						A__     :							Any   				=self._prepare_inference_func(__UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)
  						return self._measure_speed(_inference							)
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)->			[Memory, Optional[MemorySummary]]:
  						'''simple docstring'''
  
  
  						A__     :							Any   				=self._prepare_inference_func(__UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)
  						return self._measure_memory(_inference							)
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)->			float:
  						'''simple docstring'''
  
  
  						A__     :							Tuple   				=self._prepare_train_func(__UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)
  						return self._measure_speed(_train							)
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)->			[Memory, Optional[MemorySummary]]:
  						'''simple docstring'''
  
  
  						A__     :							List[Any]   				=self._prepare_train_func(__UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)
  						return self._measure_memory(_train							)
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)->			Callable[[], None]:
  						'''simple docstring'''
  
  
  						A__     :							List[Any]   				=self.config_dict[model_name]
  
  						if self.args.torchscript:
  										A__     :							Dict   				=True
  
  						A__     :							str   				=(
  						    hasattr(__UpperCamelCase	,     '''architectures'''							)
  						    and isinstance(config.architectures	,     __UpperCamelCase							)
  						    and len(config.architectures							) > 0
  						)
  						if not self.args.only_pretrain_model and has_model_class_in_config:
  										try:
  														A__     :							Any   				=config.architectures[0]
  														A__     :							Union[str, Any]   				=__import__('''transformers'''	,     fromlist=[model_class]							)
  														A__     :							Any   				=getattr(__UpperCamelCase	,     __UpperCamelCase							)
  														A__     :							Union[str, Any]   				=model_cls(__UpperCamelCase							)
  										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:
  										A__     :							Tuple   				=MODEL_MAPPING[config.__class__](__UpperCamelCase							)
  
  						model.eval()
  						model.to(self.args.device							)
  
  						# encoder-decoder has vocab size saved differently
  						A__     :							Dict   				=config.vocab_size if hasattr(__UpperCamelCase	,     '''vocab_size'''							) else config.encoder.vocab_size
  						A__     :							str   				=torch.randint(__UpperCamelCase	,     (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():
  														A__     :							Tuple   				=torch.jit.trace(__UpperCamelCase	,     __UpperCamelCase							)
  						else:
  										A__     :							Optional[int]   				=model
  
  						def encoder_decoder_forward():
  										with torch.no_grad():
  														A__     :							Tuple   				=inference_model(__UpperCamelCase	,     decoder_input_ids=__UpperCamelCase							)
  										return outputs
  
  						def encoder_forward():
  										with torch.no_grad():
  														A__     :							Any   				=inference_model(__UpperCamelCase							)
  										return outputs
  
  						A__     :							Tuple   				=encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
  						return _forward
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							)->			Callable[[], None]:
  						'''simple docstring'''
  
  
  						A__     :							str   				=self.config_dict[model_name]
  
  						A__     :							int   				=(
  						    hasattr(__UpperCamelCase	,     '''architectures'''							)
  						    and isinstance(config.architectures	,     __UpperCamelCase							)
  						    and len(config.architectures							) > 0
  						)
  						if not self.args.only_pretrain_model and has_model_class_in_config:
  										try:
  														A__     :							Tuple   				=config.architectures[0]
  														A__     :							Optional[int]   				=__import__('''transformers'''	,     fromlist=[model_class]							)
  														A__     :							Tuple   				=getattr(__UpperCamelCase	,     __UpperCamelCase							)
  														A__     :							Union[str, Any]   				=model_cls(__UpperCamelCase							)
  										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:
  										A__     :							str   				=MODEL_WITH_LM_HEAD_MAPPING[config.__class__](__UpperCamelCase							)
  
  						if self.args.torchscript:
  										raise NotImplementedError('''Training for torchscript is currently not implemented'''							)
  						else:
  										A__     :							Union[str, Any]   				=model
  
  						model.train()
  						model.to(self.args.device							)
  
  						# encoder-decoder has vocab size saved differently
  						A__     :							Any   				=config.vocab_size if hasattr(__UpperCamelCase	,     '''vocab_size'''							) else config.encoder.vocab_size
  						A__     :							Any   				=torch.randint(__UpperCamelCase	,     (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():
  										A__     :							List[Any]   				=train_model(__UpperCamelCase	,     labels=__UpperCamelCase							)[0]
  										loss.backward()
  										return loss
  
  						def compute_loss_and_backprob_encoder_decoder():
  										A__     :							Optional[int]   				=train_model(__UpperCamelCase	,     decoder_input_ids=__UpperCamelCase	,     labels=__UpperCamelCase							)[0]
  										loss.backward()
  										return loss
  
  						A__     :							int   				=(
  						    compute_loss_and_backprob_encoder_decoder
  						    if config.is_encoder_decoder
  						    else compute_loss_and_backprob_encoder
  						)
  						return _train
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase							)->			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(
  														    __UpperCamelCase	,     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
  										A__     :							List[str]   				=timeit.repeat(
  										    __UpperCamelCase	,     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(__UpperCamelCase							) / 10.0
  						except RuntimeError as e:
  										self.print_fn(F'Doesn\'t fit on GPU. {e}'							)
  										return "N/A"
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase							)->			[Memory, MemorySummary]:
  						'''simple docstring'''
  
  
  						try:
  										if self.args.trace_memory_line_by_line:
  														A__     :							Union[str, Any]   				=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.'''							)
  																		A__     :							Tuple   				='''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()
  																		A__     :							str   				=nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx							)
  																		A__     :							Optional[int]   				=nvml.nvmlDeviceGetMemoryInfo(__UpperCamelCase							)
  																		A__     :							List[str]   				=meminfo.used
  																		A__     :							Tuple   				=Memory(__UpperCamelCase							)
  																		# shutdown nvml
  																		nvml.nvmlShutdown()
  										else:
  														# cpu
  														A__     :							Optional[int]   				=measure_peak_memory_cpu(__UpperCamelCase							)
  														A__     :							Dict   				=Memory(__UpperCamelCase							) if isinstance(__UpperCamelCase	,     __UpperCamelCase							) else memory_bytes
  
  										if self.args.trace_memory_line_by_line:
  														A__     :							Dict   				=stop_memory_tracing(__UpperCamelCase							)
  										else:
  														A__     :							Union[str, Any]   				=None
  
  										return memory, summary
  						except RuntimeError as e:
  										self.print_fn(F'Doesn\'t fit on GPU. {e}'							)
  										return "N/A", None
  
  
  
  
style_context: 
  
  
  import argparse
  import copy
  import json
  import multiprocessing
  import os
  import time
  
  from create_dummy_models import COMPOSITE_MODELS, create_tiny_models
  from huggingface_hub import ModelFilter, hf_api
  
  import transformers
  from transformers import AutoFeatureExtractor, AutoImageProcessor, AutoTokenizer
  from transformers.image_processing_utils import BaseImageProcessor
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							)			->							Tuple:
  				A__     :							List[Any]   				=set()
  				# Each auto modeling files contains multiple mappings. Let's get them in a dynamic way.
  				for module_name in ["modeling_auto", "modeling_tf_auto", "modeling_flax_auto"]:
  								A__     :							Optional[int]   				=getattr(transformers.models.auto,	snake_case_,	snake_case_	)
  								if module is None:
  												continue
  								# all mappings in a single auto modeling file
  								A__     :							Optional[int]   				=[
  								    x
  								    for x in dir(snake_case_	)
  								    if x.endswith('''_MAPPING_NAMES'''	)
  								    and (x.startswith('''MODEL_'''	) or x.startswith('''TF_MODEL_'''	) or x.startswith('''FLAX_MODEL_'''	))
  								]
  								for name in mapping_names:
  												A__     :							Any   				=getattr(snake_case_,	snake_case_	)
  												if mapping is not None:
  																for v in mapping.values():
  																				if isinstance(snake_case_,	(list, tuple)	):
  																								model_names.update(snake_case_	)
  																				elif isinstance(snake_case_,	snake_case_	):
  																								model_names.add(snake_case_	)
  
  				return sorted(snake_case_	)
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							)			->							Optional[Any]:
  				# All model names defined in auto mappings
  				A__     :							int   				=set(get_all_model_names()	)
  
  				with open('''tests/utils/tiny_model_summary.json'''	) as fp:
  								A__     :							Union[str, Any]   				=json.load(snake_case_	)
  				A__     :							int   				=set()
  				for model_base_name in tiny_model_info:
  								tiny_models_names.update(tiny_model_info[model_base_name]['''model_classes''']	)
  
  				# Remove a tiny model name if one of its framework implementation hasn't yet a tiny version on the Hub.
  				A__     :							Optional[Any]   				=model_names.difference(snake_case_	)
  				for model_name in copy.copy(snake_case_	):
  								if not model_name.startswith('''TF'''	) and f'TF{model_name}' in not_on_hub:
  												tiny_models_names.remove(snake_case_	)
  								elif model_name.startswith('''TF'''	) and model_name[2:] in not_on_hub:
  												tiny_models_names.remove(snake_case_	)
  
  				return sorted(snake_case_	)
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							Tuple:
  				A__     :							Dict   				=COMPOSITE_MODELS.values()
  
  				# All tiny model base names on Hub
  				A__     :							Union[str, Any]   				=get_all_model_names()
  				A__     :							Optional[Any]   				=hf_api.list_models(
  				    filter=ModelFilter(
  				        author='''hf-internal-testing''',	)	)
  				A__     :							str   				=set()
  				for x in models:
  								A__     :							List[Any]   				=x.modelId
  								A__				,  A__     :							List[str]   				=model.split('''/'''	)
  								if not model.startswith('''tiny-random-'''	):
  												continue
  								A__     :							str   				=model.replace('''tiny-random-''',	''''''	)
  								if not model[0].isupper():
  												continue
  								if model not in model_names and model not in special_models:
  												continue
  								_models.add(snake_case_	)
  
  				A__     :							Dict   				=sorted(_models	)
  				# All tiny model names on Hub
  				A__     :							Optional[int]   				={}
  				for model in models:
  								A__     :							Optional[int]   				=f'hf-internal-testing/tiny-random-{model}'
  								A__     :							str   				=model.split('''-'''	)[0]
  								try:
  												A__     :							int   				=hf_api.repo_info(snake_case_	)
  												A__     :							Optional[int]   				={
  												    '''tokenizer_classes''': set(),
  												    '''processor_classes''': set(),
  												    '''model_classes''': set(),
  												    '''sha''': repo_info.sha,
  												}
  								except Exception:
  												continue
  								try:
  												time.sleep(1	)
  												A__     :							List[str]   				=AutoTokenizer.from_pretrained(snake_case_	)
  												content["tokenizer_classes"].add(tokenizer_fast.__class__.__name__	)
  								except Exception:
  												pass
  								try:
  												time.sleep(1	)
  												A__     :							int   				=AutoTokenizer.from_pretrained(snake_case_,	use_fast=snake_case_	)
  												content["tokenizer_classes"].add(tokenizer_slow.__class__.__name__	)
  								except Exception:
  												pass
  								try:
  												time.sleep(1	)
  												A__     :							int   				=AutoImageProcessor.from_pretrained(snake_case_	)
  												content["processor_classes"].add(img_p.__class__.__name__	)
  								except Exception:
  												pass
  								try:
  												time.sleep(1	)
  												A__     :							Optional[int]   				=AutoFeatureExtractor.from_pretrained(snake_case_	)
  												if not isinstance(snake_case_,	snake_case_	):
  																content["processor_classes"].add(feat_p.__class__.__name__	)
  								except Exception:
  												pass
  								try:
  												time.sleep(1	)
  												A__     :							Tuple   				=getattr(snake_case_,	snake_case_	)
  												A__     :							Tuple   				=model_class.from_pretrained(snake_case_	)
  												content["model_classes"].add(m.__class__.__name__	)
  								except Exception:
  												pass
  								try:
  												time.sleep(1	)
  												A__     :							int   				=getattr(snake_case_,	f'TF{model}'	)
  												A__     :							Union[str, Any]   				=model_class.from_pretrained(snake_case_	)
  												content["model_classes"].add(m.__class__.__name__	)
  								except Exception:
  												pass
  
  								A__     :							List[str]   				=sorted(content['''tokenizer_classes''']	)
  								A__     :							Tuple   				=sorted(content['''processor_classes''']	)
  								A__     :							Optional[Any]   				=sorted(content['''model_classes''']	)
  
  								A__     :							List[Any]   				=content
  								with open(os.path.join(snake_case_,	'''hub_tiny_model_summary.json'''	),	'''w'''	) as fp:
  												json.dump(snake_case_,	snake_case_,	ensure_ascii=snake_case_,	indent=4	)
  
  
  if __name__ == "__main__":
  						__lowerCamelCase       :       Any				   =			argparse.ArgumentParser()
  						parser.add_argument("--num_workers", default=1, type=int, help="The number of workers to run.")
  						__lowerCamelCase       :       int				   =			parser.parse_args()
  
  						# This has to be `spawn` to avoid hanging forever!
  						multiprocessing.set_start_method("spawn")
  
  						__lowerCamelCase       :       Any				   =			"tiny_models"
  						__lowerCamelCase       :       Optional[int]				   =			True
  						__lowerCamelCase       :       int				   =			None
  						__lowerCamelCase       :       str				   =			get_tiny_model_names_from_repo()
  						__lowerCamelCase       :       List[Any]				   =			True
  						__lowerCamelCase       :       List[Any]				   =			True
  						__lowerCamelCase       :       Optional[Any]				   =			"hf-internal-testing"
  
  						create_tiny_models(
  						    output_path,
  						    all,
  						    model_types,
  						    models_to_skip,
  						    no_check,
  						    upload,
  						    organization,
  						    token=os.environ.get("TOKEN", None),
  						    num_workers=args.num_workers,
  						)
  
  
  
  