





'''simple docstring'''


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       A							(      )  ->				List[str]:


  '''simple docstring'''




  __lowerCAmelCase		:    Optional[int]			     =  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"]:
    __lowerCAmelCase		:    int			     =  getattr(transformers.models.auto						,_UpperCAmelCase						,_UpperCAmelCase					)
    if module is None:
      continue
    # all mappings in a single auto modeling file
    __lowerCAmelCase		:    Optional[int]			     =  [
        x
        for x in dir(_UpperCAmelCase					)
        if x.endswith('_MAPPING_NAMES'					)
        and (x.startswith('MODEL_'					) or x.startswith('TF_MODEL_'					) or x.startswith('FLAX_MODEL_'					))
    ]
    for name in mapping_names:
      __lowerCAmelCase		:    Union[str, Any]			     =  getattr(_UpperCAmelCase						,_UpperCAmelCase					)
      if mapping is not None:
        for v in mapping.values():
          if isinstance(_UpperCAmelCase						,(list, tuple)					):
            model_names.update(_UpperCAmelCase					)
          elif isinstance(_UpperCAmelCase						,_UpperCAmelCase					):
            model_names.add(_UpperCAmelCase					)

  return sorted(_UpperCAmelCase					)




def       A							(      )  ->				Dict:


  '''simple docstring'''




  __lowerCAmelCase		:    Optional[int]			     =  set(get_all_model_names()					)

  with open('tests/utils/tiny_model_summary.json'					) as fp:
    __lowerCAmelCase		:    Optional[Any]			     =  json.load(_UpperCAmelCase					)
  __lowerCAmelCase		:    List[str]			     =  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.
  __lowerCAmelCase		:    str			     =  model_names.difference(_UpperCAmelCase					)
  for model_name in copy.copy(_UpperCAmelCase					):
    if not model_name.startswith('TF'					) and F"""TF{model_name}""" in not_on_hub:
      tiny_models_names.remove(_UpperCAmelCase					)
    elif model_name.startswith('TF'					) and model_name[2:] in not_on_hub:
      tiny_models_names.remove(_UpperCAmelCase					)

  return sorted(_UpperCAmelCase					)




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


  '''simple docstring'''




  __lowerCAmelCase		:    int			     =  COMPOSITE_MODELS.values()

  # All tiny model base names on Hub
  __lowerCAmelCase		:    Union[str, Any]			     =  get_all_model_names()
  __lowerCAmelCase		:    List[Any]			     =  hf_api.list_models(
      filter=ModelFilter(
          author='hf-internal-testing'						,)					)
  __lowerCAmelCase		:    Tuple			     =  set()
  for x in models:
    __lowerCAmelCase		:    int			     =  x.modelId
    __lowerCAmelCase     ,					__lowerCAmelCase		:    str			     =  model.split('/'					)
    if not model.startswith('tiny-random-'					):
      continue
    __lowerCAmelCase		:    Optional[Any]			     =  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(_UpperCAmelCase					)

  __lowerCAmelCase		:    Any			     =  sorted(_models					)
  # All tiny model names on Hub
  __lowerCAmelCase		:    List[str]			     =  {}
  for model in models:
    __lowerCAmelCase		:    List[str]			     =  F"""hf-internal-testing/tiny-random-{model}"""
    __lowerCAmelCase		:    int			     =  model.split('-'					)[0]
    try:
      __lowerCAmelCase		:    List[str]			     =  hf_api.repo_info(_UpperCAmelCase					)
      __lowerCAmelCase		:    str			     =  {
          'tokenizer_classes': set(),
          'processor_classes': set(),
          'model_classes': set(),
          'sha': repo_info.sha,
      }
    except Exception:
      continue
    try:
      time.sleep(1					)
      __lowerCAmelCase		:    Dict			     =  AutoTokenizer.from_pretrained(_UpperCAmelCase					)
      content["tokenizer_classes"].add(tokenizer_fast.__class__.__name__					)
    except Exception:
      pass
    try:
      time.sleep(1					)
      __lowerCAmelCase		:    Dict			     =  AutoTokenizer.from_pretrained(_UpperCAmelCase						,use_fast=_UpperCAmelCase					)
      content["tokenizer_classes"].add(tokenizer_slow.__class__.__name__					)
    except Exception:
      pass
    try:
      time.sleep(1					)
      __lowerCAmelCase		:    int			     =  AutoImageProcessor.from_pretrained(_UpperCAmelCase					)
      content["processor_classes"].add(img_p.__class__.__name__					)
    except Exception:
      pass
    try:
      time.sleep(1					)
      __lowerCAmelCase		:    Dict			     =  AutoFeatureExtractor.from_pretrained(_UpperCAmelCase					)
      if not isinstance(_UpperCAmelCase						,_UpperCAmelCase					):
        content["processor_classes"].add(feat_p.__class__.__name__					)
    except Exception:
      pass
    try:
      time.sleep(1					)
      __lowerCAmelCase		:    Optional[Any]			     =  getattr(_UpperCAmelCase						,_UpperCAmelCase					)
      __lowerCAmelCase		:    Dict			     =  model_class.from_pretrained(_UpperCAmelCase					)
      content["model_classes"].add(m.__class__.__name__					)
    except Exception:
      pass
    try:
      time.sleep(1					)
      __lowerCAmelCase		:    List[Any]			     =  getattr(_UpperCAmelCase						,F"""TF{model}"""					)
      __lowerCAmelCase		:    Optional[int]			     =  model_class.from_pretrained(_UpperCAmelCase					)
      content["model_classes"].add(m.__class__.__name__					)
    except Exception:
      pass

    __lowerCAmelCase		:    Optional[Any]			     =  sorted(content['tokenizer_classes']					)
    __lowerCAmelCase		:    int			     =  sorted(content['processor_classes']					)
    __lowerCAmelCase		:    Optional[int]			     =  sorted(content['model_classes']					)

    __lowerCAmelCase		:    int			     =  content
    with open(os.path.join(_UpperCAmelCase						,'hub_tiny_model_summary.json'					)						,'w'					) as fp:
      json.dump(_UpperCAmelCase						,_UpperCAmelCase						,ensure_ascii=_UpperCAmelCase						,indent=4					)


if __name__ == "__main__":
    A_				     =							argparse.ArgumentParser()
    parser.add_argument("--num_workers", default=1, type=int, help="The number of workers to run.")
    A_				     =							parser.parse_args()

    # This has to be `spawn` to avoid hanging forever!
    multiprocessing.set_start_method("spawn")

    A_				     =							"tiny_models"
    A_				     =							True
    A_				     =							None
    A_				     =							get_tiny_model_names_from_repo()
    A_				     =							True
    A_				     =							True
    A_				     =							"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,
    )












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


A_				     =							logging.get_logger(__name__)


class 		UpperCamelCase__     (       a							):
      '''simple docstring'''






      _snake_case           =				42
      _snake_case           =				42
      _snake_case           =				"PyTorch"




      @property
      def 	snake_case  (     self )				->  Dict:
        return torch.__version__




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  float:
        __lowerCAmelCase		:    Any			     =  self._prepare_inference_func(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )
        return self._measure_speed(_inference )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  [Memory, Optional[MemorySummary]]:
        __lowerCAmelCase		:    Dict			     =  self._prepare_inference_func(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )
        return self._measure_memory(_inference )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  float:
        __lowerCAmelCase		:    Optional[Any]			     =  self._prepare_train_func(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )
        return self._measure_speed(_train )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  [Memory, Optional[MemorySummary]]:
        __lowerCAmelCase		:    Optional[int]			     =  self._prepare_train_func(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )
        return self._measure_memory(_train )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  Callable[[], None]:
        __lowerCAmelCase		:    str			     =  self.config_dict[model_name]

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

        __lowerCAmelCase		:    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:
            __lowerCAmelCase		:    Dict			     =  config.architectures[0]
            __lowerCAmelCase		:    List[str]			     =  __import__('transformers'     , fromlist=[model_class] )
            __lowerCAmelCase		:    Tuple			     =  getattr(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )
            __lowerCAmelCase		:    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:
          __lowerCAmelCase		:    List[Any]			     =  MODEL_MAPPING[config.__class__](SCREAMING_SNAKE_CASE )

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

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

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

        def encoder_forward():
          with torch.no_grad():
            __lowerCAmelCase		:    str			     =  inference_model(SCREAMING_SNAKE_CASE )
          return outputs

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




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  Callable[[], None]:
        __lowerCAmelCase		:    int			     =  self.config_dict[model_name]

        __lowerCAmelCase		:    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:
            __lowerCAmelCase		:    List[Any]			     =  config.architectures[0]
            __lowerCAmelCase		:    List[str]			     =  __import__('transformers'     , fromlist=[model_class] )
            __lowerCAmelCase		:    Tuple			     =  getattr(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )
            __lowerCAmelCase		:    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:
          __lowerCAmelCase		:    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:
          __lowerCAmelCase		:    int			     =  model

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

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

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

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




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE )				->  float:
        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
          __lowerCAmelCase		:    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 ) / 1_0.0
        except RuntimeError as e:
          self.print_fn(F"""Doesn't fit on GPU. {e}""" )
          return "N/A"







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

          if self.args.trace_memory_line_by_line:
            __lowerCAmelCase		:    int			     =  stop_memory_tracing(SCREAMING_SNAKE_CASE )
          else:
            __lowerCAmelCase		:    Any			     =  None

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





