




'''simple docstring'''
import multiprocessing
import os
from typing import BinaryIO, Optional, Union

from .. import Dataset, Features, NamedSplit, config
from ..formatting import query_table
from ..packaged_modules.csv.csv import Csv
from ..utils import logging
from ..utils.typing import NestedDataStructureLike, PathLike
from .abc import AbstractDatasetReader






class 			SCREAMING_SNAKE_CASE(							UpperCAmelCase_	):

       def __init__(       self   ,						lowerCamelCase__   ,						lowerCamelCase__ = None   ,						lowerCamelCase__ = None   ,						lowerCamelCase__ = None   ,						lowerCamelCase__ = False   ,						lowerCamelCase__ = False   ,						lowerCamelCase__ = None   ,						**lowerCamelCase__   ,						)       ->   Dict:

           """simple docstring"""



           super().__init__(
               SCREAMING_SNAKE_CASE_   ,						split=SCREAMING_SNAKE_CASE_   ,						features=SCREAMING_SNAKE_CASE_   ,						cache_dir=SCREAMING_SNAKE_CASE_   ,						keep_in_memory=SCREAMING_SNAKE_CASE_   ,						streaming=SCREAMING_SNAKE_CASE_   ,						num_proc=SCREAMING_SNAKE_CASE_   ,						**SCREAMING_SNAKE_CASE_   ,						)
           __lowercase     							=		path_or_paths if isinstance(SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_	) else {self.split: path_or_paths}
           __lowercase     							=		Csv(
               cache_dir=SCREAMING_SNAKE_CASE_   ,						data_files=SCREAMING_SNAKE_CASE_   ,						features=SCREAMING_SNAKE_CASE_   ,						**SCREAMING_SNAKE_CASE_   ,						)




       def        snake_case__     (       self	)       ->   Optional[Any]:

           """simple docstring"""



           if self.streaming:
               __lowercase     							=		self.builder.as_streaming_dataset(split=self.split	)
           # Build regular (map-style) dataset
           else:
               __lowercase     							=		None
               __lowercase     							=		None
               __lowercase     							=		None
               __lowercase     							=		None

               self.builder.download_and_prepare(
                   download_config=SCREAMING_SNAKE_CASE_   ,						download_mode=SCREAMING_SNAKE_CASE_   ,						verification_mode=SCREAMING_SNAKE_CASE_   ,						base_path=SCREAMING_SNAKE_CASE_   ,						num_proc=self.num_proc   ,						)
               __lowercase     							=		self.builder.as_dataset(
                   split=self.split   ,						verification_mode=SCREAMING_SNAKE_CASE_   ,						in_memory=self.keep_in_memory	)
           return dataset






class 			SCREAMING_SNAKE_CASE:

       def __init__(       self   ,						lowerCamelCase__   ,						lowerCamelCase__   ,						lowerCamelCase__ = None   ,						lowerCamelCase__ = None   ,						**lowerCamelCase__   ,						)       ->   Optional[Any]:

           """simple docstring"""



           if num_proc is not None and num_proc <= 0:
               raise ValueError(F'num_proc {num_proc} must be an integer > 0.'	)

           __lowercase     							=		dataset
           __lowercase     							=		path_or_buf
           __lowercase     							=		batch_size if batch_size else config.DEFAULT_MAX_BATCH_SIZE
           __lowercase     							=		num_proc
           __lowercase     							=		'''utf-8'''
           __lowercase     							=		to_csv_kwargs

       def        snake_case__     (       self	)       ->   int:

           """simple docstring"""



           __lowercase     							=		self.to_csv_kwargs.pop("""path_or_buf"""   ,						SCREAMING_SNAKE_CASE_	)
           __lowercase     							=		self.to_csv_kwargs.pop("""header"""   ,						SCREAMING_SNAKE_CASE_	)
           __lowercase     							=		self.to_csv_kwargs.pop("""index"""   ,						SCREAMING_SNAKE_CASE_	)

           if isinstance(self.path_or_buf   ,						(str, bytes, os.PathLike)	):
               with open(self.path_or_buf   ,						"""wb+"""	) as buffer:
                   __lowercase     							=		self._write(file_obj=SCREAMING_SNAKE_CASE_   ,						header=SCREAMING_SNAKE_CASE_   ,						index=SCREAMING_SNAKE_CASE_   ,						**self.to_csv_kwargs	)
           else:
               __lowercase     							=		self._write(file_obj=self.path_or_buf   ,						header=SCREAMING_SNAKE_CASE_   ,						index=SCREAMING_SNAKE_CASE_   ,						**self.to_csv_kwargs	)
           return written

       def        snake_case__     (       self   ,						lowerCamelCase__	)       ->   Union[str, Any]:

           """simple docstring"""



           __lowercase     							=		args

           __lowercase     							=		query_table(
               table=self.dataset.data   ,						key=slice(SCREAMING_SNAKE_CASE_   ,						offset + self.batch_size	)   ,						indices=self.dataset._indices   ,						)
           __lowercase     							=		batch.to_pandas().to_csv(
               path_or_buf=SCREAMING_SNAKE_CASE_   ,						header=header if (offset == 0) else False   ,						index=SCREAMING_SNAKE_CASE_   ,						**SCREAMING_SNAKE_CASE_	)
           return csv_str.encode(self.encoding	)




       def        snake_case__     (       self   ,						lowerCamelCase__   ,						lowerCamelCase__   ,						lowerCamelCase__   ,						**lowerCamelCase__	)       ->   int:

           """simple docstring"""



           __lowercase     							=		0

           if self.num_proc is None or self.num_proc == 1:
               for offset in logging.tqdm(
                   range(0   ,						len(self.dataset	)   ,						self.batch_size	)   ,						unit="""ba"""   ,						disable=not logging.is_progress_bar_enabled()   ,						desc="""Creating CSV from Arrow format"""   ,						):
                   __lowercase     							=		self._batch_csv((offset, header, index, to_csv_kwargs)	)
                   written += file_obj.write(SCREAMING_SNAKE_CASE_	)

           else:
               __lowercase     							=		len(self.dataset	), self.batch_size
               with multiprocessing.Pool(self.num_proc	) as pool:
                   for csv_str in logging.tqdm(
                       pool.imap(
                           self._batch_csv   ,						[(offset, header, index, to_csv_kwargs) for offset in range(0   ,						SCREAMING_SNAKE_CASE_   ,						SCREAMING_SNAKE_CASE_	)]   ,						)   ,						total=(num_rows // batch_size) + 1 if num_rows % batch_size else num_rows // batch_size   ,						unit="""ba"""   ,						disable=not logging.is_progress_bar_enabled()   ,						desc="""Creating CSV from Arrow format"""   ,						):
                       written += file_obj.write(SCREAMING_SNAKE_CASE_	)

           return written










'''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 						lowerCAmelCase_	(       UpperCAmelCase_							):







  '''simple docstring'''

  UpperCamelCase_			:      PyTorchBenchmarkArguments
  UpperCamelCase_			:      PretrainedConfig
  UpperCamelCase_			:      str										=				"PyTorch"



  @property
  def 					_snake_case     ( self				:							int	)			->		List[str]:







       '''simple docstring'''



       return torch.__version__



  def 					_snake_case     ( self				:							Dict					,  SCREAMING_SNAKE_CASE_				:							str					,  SCREAMING_SNAKE_CASE_				:							int					,  SCREAMING_SNAKE_CASE_				:							int	)			->		float:







       '''simple docstring'''



       A:		List[str]          =		self._prepare_inference_func(SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_	)
       return self._measure_speed(_inference	)



  def 					_snake_case     ( self				:							Dict					,  SCREAMING_SNAKE_CASE_				:							str					,  SCREAMING_SNAKE_CASE_				:							int					,  SCREAMING_SNAKE_CASE_				:							int	)			->		[Memory, Optional[MemorySummary]]:







       '''simple docstring'''



       A:		Any          =		self._prepare_inference_func(SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_	)
       return self._measure_memory(_inference	)



  def 					_snake_case     ( self				:							List[str]					,  SCREAMING_SNAKE_CASE_				:							str					,  SCREAMING_SNAKE_CASE_				:							int					,  SCREAMING_SNAKE_CASE_				:							int	)			->		float:







       '''simple docstring'''



       A:		List[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_				:							str					,  SCREAMING_SNAKE_CASE_				:							int					,  SCREAMING_SNAKE_CASE_				:							int	)			->		[Memory, Optional[MemorySummary]]:







       '''simple docstring'''



       A:		List[Any]          =		self._prepare_train_func(SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_	)
       return self._measure_memory(_train	)



  def 					_snake_case     ( self				:							Union[str, Any]					,  SCREAMING_SNAKE_CASE_				:							str					,  SCREAMING_SNAKE_CASE_				:							int					,  SCREAMING_SNAKE_CASE_				:							int	)			->		Callable[[], None]:







       '''simple docstring'''



       A:		int          =		self.config_dict[model_name]

       if self.args.torchscript:
            A:		int          =		True

       A:		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:
                 A:		Optional[int]          =		config.architectures[0]
                 A:		Optional[int]          =		__import__('''transformers'''					,  fromlist=[model_class]	)
                 A:		Dict          =		getattr(SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_	)
                 A:		Optional[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:
            A:		Union[str, Any]          =		MODEL_MAPPING[config.__class__](SCREAMING_SNAKE_CASE_	)

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

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

       def encoder_decoder_forward():
            with torch.no_grad():
                 A:		List[str]          =		inference_model(SCREAMING_SNAKE_CASE_					,  decoder_input_ids=SCREAMING_SNAKE_CASE_	)
            return outputs

       def encoder_forward():
            with torch.no_grad():
                 A:		Union[str, Any]          =		inference_model(SCREAMING_SNAKE_CASE_	)
            return outputs

       A:		List[Any]          =		encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
       return _forward



  def 					_snake_case     ( self				:							Tuple					,  SCREAMING_SNAKE_CASE_				:							str					,  SCREAMING_SNAKE_CASE_				:							int					,  SCREAMING_SNAKE_CASE_				:							int	)			->		Callable[[], None]:







       '''simple docstring'''



       A:		int          =		self.config_dict[model_name]

       A:		str          =		(
           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:
                 A:		List[str]          =		config.architectures[0]
                 A:		List[str]          =		__import__('''transformers'''					,  fromlist=[model_class]	)
                 A:		Optional[int]          =		getattr(SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_	)
                 A:		Union[str, 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:
            A:		Union[str, Any]          =		MODEL_WITH_LM_HEAD_MAPPING[config.__class__](SCREAMING_SNAKE_CASE_	)

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

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

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

       def compute_loss_and_backprob_encoder_decoder():
            A:		Dict          =		train_model(SCREAMING_SNAKE_CASE_					,  decoder_input_ids=SCREAMING_SNAKE_CASE_					,  labels=SCREAMING_SNAKE_CASE_	)[0]
            loss.backward()
            return loss

       A:		str          =		(
           compute_loss_and_backprob_encoder_decoder
           if config.is_encoder_decoder
           else compute_loss_and_backprob_encoder
       )
       return _train



  def 					_snake_case     ( self				:							Any					,  SCREAMING_SNAKE_CASE_				:							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(
                     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
            A:		Any          =		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				:							Optional[int]					,  SCREAMING_SNAKE_CASE_				:							Callable[[], None]	)			->		[Memory, MemorySummary]:







       '''simple docstring'''



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

            if self.args.trace_memory_line_by_line:
                 A:		Dict          =		stop_memory_tracing(SCREAMING_SNAKE_CASE_	)
            else:
                 A:		List[str]          =		None

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






