




'''simple docstring'''



from dataclasses import dataclass, field
from typing import Optional






@dataclass
class 							_a				:





       '''simple docstring'''






       A						:				Optional[str]        =						field(
           default='''codeparrot/codeparrot''' ,      metadata={'''help''': '''Model name or path of model to be trained.'''} )
       A						:				Optional[str]        =						field(
           default='''./''' ,      metadata={'''help''': '''Save dir where model repo is cloned and models updates are saved to.'''} )
       A						:				Optional[str]        =						field(
           default='''codeparrot/codeparrot-clean-train''' ,      metadata={'''help''': '''Name or path of training dataset.'''} )
       A						:				Optional[str]        =						field(
           default='''codeparrot/codeparrot-clean-valid''' ,      metadata={'''help''': '''Name or path of validation dataset.'''} )
       A						:				Optional[int]        =						field(default=2 ,      metadata={'''help''': '''Batch size for training.'''} )
       A						:				Optional[int]        =						field(default=2 ,      metadata={'''help''': '''Batch size for evaluation.'''} )
       A						:				Optional[float]        =						field(default=0.1 ,      metadata={'''help''': '''Value of weight decay.'''} )
       A						:				Optional[int]        =						field(
           default=10_000 ,      metadata={'''help''': '''Size of buffer used to shuffle streaming dataset.'''} )
       A						:				Optional[float]        =						field(default=2e-4 ,      metadata={'''help''': '''Learning rate fo training.'''} )
       A						:				Optional[str]        =						field(default='''cosine''' ,      metadata={'''help''': '''Learning rate.'''} )
       A						:				Optional[int]        =						field(
           default=750 ,      metadata={'''help''': '''Number of warmup steps in the learning rate schedule.'''} )
       A						:				Optional[int]        =						field(
           default=16 ,      metadata={'''help''': '''Number of gradient accumulation steps.'''} )
       A						:				Optional[bool]        =						field(
           default=SCREAMING_SNAKE_CASE ,      metadata={'''help''': '''Use gradient checkpointing to reduce memory footprint.'''} )
       A						:				Optional[int]        =						field(default=50_000 ,      metadata={'''help''': '''Maximum number of training steps.'''} )
       A						:				Optional[int]        =						field(
           default=-1 ,      metadata={'''help''': '''Maximum number of evaluation steps. If -1 the full dataset is evaluated.'''} )
       A						:				Optional[int]        =						field(default=1_024 ,      metadata={'''help''': '''Sequence lengths used for training.'''} )
       A						:				Optional[int]        =						field(default=1 ,      metadata={'''help''': '''Training seed.'''} )
       A						:				Optional[int]        =						field(
           default=1_024 ,      metadata={'''help''': '''Interval to save checkpoints. Measured as number of forward passes not training steps.'''} ,      )
       A						:				Optional[str]        =						field(
           default=SCREAMING_SNAKE_CASE ,      metadata={'''help''': '''States path if the training should continue from a checkpoint folder.'''} )
       A						:				Optional[bool]        =						field(default=SCREAMING_SNAKE_CASE ,      metadata={'''help''': '''If True the data is pretokenized.'''} )






@dataclass
class 							_a				:





       '''simple docstring'''






       A						:				Optional[str]        =						field(
           default='''codeparrot/codeparrot''' ,      metadata={'''help''': '''Model name or path of model to be evaluated.'''} )
       A						:				Optional[str]        =						field(
           default='''codeparrot/codeparrot-clean-valid''' ,      metadata={'''help''': '''Name or path of validation dataset.'''} )
       A						:				Optional[int]        =						field(default=2 ,      metadata={'''help''': '''Batch size used for evaluation.'''} )
       A						:				Optional[int]        =						field(
           default=-1 ,      metadata={'''help''': '''Maximum number of evaluation steps. If -1 the full dataset is evaluated.'''} )
       A						:				Optional[int]        =						field(default=1_024 ,      metadata={'''help''': '''Length of sequences to be evaluated.'''} )
       A						:				Optional[int]        =						field(default=1 ,      metadata={'''help''': '''Random seed used for evaluation.'''} )






@dataclass
class 							_a				:





       '''simple docstring'''






       A						:				Optional[str]        =						field(
           default='''codeparrot/codeparrot''' ,      metadata={'''help''': '''Model name or path of model to be evaluated.'''} )
       A						:				Optional[int]        =						field(default=SCREAMING_SNAKE_CASE ,      metadata={'''help''': '''Number of workers used for code evaluation.'''} )
       A						:				Optional[int]        =						field(
           default=SCREAMING_SNAKE_CASE ,      metadata={'''help''': '''The number of human-eval tasks to run. If not included all tasks are evaluated.'''} ,      )
       A						:				Optional[bool]        =						field(
           default=SCREAMING_SNAKE_CASE ,      metadata={'''help''': '''Sample from the language model\'s output distribution.'''} )
       A						:				Optional[float]        =						field(default=0.2 ,      metadata={'''help''': '''Sampling temperature used for generation.'''} )
       A						:				Optional[int]        =						field(default=256 ,      metadata={'''help''': '''Maximum number of newly generated tokens.'''} )
       A						:				Optional[int]        =						field(default=0 ,      metadata={'''help''': '''Top-k parameter used for generation.'''} )
       A						:				Optional[float]        =						field(default=0.95 ,      metadata={'''help''': '''Top-p parameter used for nucleus sampling.'''} )
       A						:				Optional[int]        =						field(default=10 ,      metadata={'''help''': '''Number of generations to run in parallel.'''} )
       A						:				Optional[int]        =						field(
           default=200 ,      metadata={'''help''': '''Number of completions to generate for each sample.'''} )
       A						:				Optional[int]        =						field(default=1 ,      metadata={'''help''': '''Random seed used for evaluation.'''} )
       A						:				Optional[str]        =						field(
           default='''eval_results.json''' ,      metadata={'''help''': '''Random seed used for evaluation.'''} )
       A						:				Optional[str]        =						field(
           default='''0''' ,      metadata={'''help''': '''Allow `code_eval` to execute Python code on machine'''} )
       A						:				Optional[int]        =						field(
           default=-1 ,      metadata={
               '''help''': (
                   '''Determine which device to run the `text-generation` Pipeline on. -1 is CPU and any zero or positive'''
                   ''' number corresponds to which GPU device id to run on.'''
               )
           } ,      )






@dataclass
class 							_a				:





       '''simple docstring'''






       A						:				Optional[int]        =						field(
           default=SCREAMING_SNAKE_CASE ,      metadata={
               '''help''': '''The number of CPU cores to use for parallel preprocessing. Default uses the maximum available.'''
           } ,      )
       A						:				Optional[str]        =						field(
           default='''transformersbook/codeparrot''' ,      metadata={'''help''': '''Folder or name of dataset to process.'''} )
       A						:				Optional[str]        =						field(
           default='''codeparrot-clean''' ,      metadata={'''help''': '''Folder to save processed processed dataset.'''} )
       A						:				Optional[int]        =						field(
           default=100_000 ,      metadata={'''help''': '''Number of files to save per JSON output file.'''} )
       A						:				Optional[str]        =						field(default='''content''' ,      metadata={'''help''': '''Column containing text data to process.'''} )
       A						:				Optional[float]        =						field(
           default=1_000 ,      metadata={'''help''': '''Maximum line length in file, otherwise file is filtered.'''} )
       A						:				Optional[float]        =						field(
           default=100 ,      metadata={'''help''': '''Maximum mean line length in file, otherwise file is filtered.'''} )
       A						:				Optional[float]        =						field(
           default=0.25 ,      metadata={'''help''': '''Maximum fraction of non-alphanumeric characters, otherwise file is filtered.'''} )
       A						:				Optional[float]        =						field(
           default=1.5 ,      metadata={'''help''': '''Minimum character token ratio for the file, otherwise file is filtered.'''} )
       A						:				Optional[float]        =						field(
           default=0.7 ,      metadata={'''help''': '''Probability for filtering config, test and uncommon files.'''} )
       A						:				Optional[str]        =						field(
           default='''codeparrot/codeparrot''' ,      metadata={'''help''': '''Name or path to the tokenizer.'''} ,      )
       A						:				Optional[bool]        =						field(
           default=SCREAMING_SNAKE_CASE ,      metadata={'''help''': '''If True, near-duplicate samples are removed.'''} )
       A						:				Optional[float]        =						field(
           default=0.85 ,      metadata={'''help''': '''Jaccard threshold for near-duplicate samples.'''} )






@dataclass
class 							_a				:





       '''simple docstring'''






       A						:				Optional[str]        =						field(
           default='''gpt2''' ,      metadata={'''help''': '''Base tokenizer to build new tokenizer from.'''} )
       A						:				Optional[str]        =						field(
           default='''transformersbook/codeparrot-train''' ,      metadata={'''help''': '''Dataset to train tokenizer on.'''} )
       A						:				Optional[str]        =						field(default='''content''' ,      metadata={'''help''': '''Column containing text data to process.'''} )
       A						:				Optional[int]        =						field(default=200_000 ,      metadata={'''help''': '''Number of examples to train tokenizer on.'''} )
       A						:				Optional[int]        =						field(
           default=32_768 ,      metadata={'''help''': '''Number of examples to train the tokenizer on.'''} )
       A						:				Optional[str]        =						field(default='''codeparrot''' ,      metadata={'''help''': '''Name of new tokenizer.'''} )
       A						:				Optional[bool]        =						field(default=SCREAMING_SNAKE_CASE ,      metadata={'''help''': '''Push saved tokenizer to the hub.'''} )






@dataclass
class 							_a				:





       '''simple docstring'''






       A						:				Optional[str]        =						field(
           default='''codeparrot/codeparrot''' ,      metadata={'''help''': '''Name or path to the tokenizer.'''} )
       A						:				Optional[str]        =						field(
           default='''codeparrot/codeparrot-clean-train''' ,      metadata={'''help''': '''Name or path to the dataset to pretokenize.'''} )
       A						:				Optional[str]        =						field(
           default='''tokenized-codeparrot-train''' ,      metadata={'''help''': '''Repo name of the pretokenized data.'''} )
       A						:				Optional[int]        =						field(default=SCREAMING_SNAKE_CASE ,      metadata={'''help''': '''Number of workers used for code evaluation.'''} )






@dataclass
class 							_a				:





       '''simple docstring'''






       A						:				Optional[str]        =						field(
           default='''gpt2-large''' ,      metadata={'''help''': '''Configuration to use for model initialization.'''} )
       A						:				Optional[str]        =						field(
           default='''codeparrot/codeparrot''' ,      metadata={'''help''': '''Tokenizer attached to model.'''} )
       A						:				Optional[str]        =						field(default='''codeparrot''' ,      metadata={'''help''': '''Name of the created model.'''} )
       A						:				Optional[bool]        =						field(default=SCREAMING_SNAKE_CASE ,      metadata={'''help''': '''Push saved tokenizer to the hub.'''} )








'''simple docstring'''



from math import ceil
from typing import List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import BatchFeature, SequenceFeatureExtractor
from ...utils import TensorType, logging


UpperCamelCase_    	=				logging.get_logger(__name__)






class 							_a				(			SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				str        =						['''audio_values''', '''audio_mask''']







       def __init__(      self,							A=2_048,							A=1,							A=[16, 16],							A=128,							A=44_100,							A=86,							A=2_048,							A=0.0,							**A,							):







             '''simple docstring'''







             super().__init__(
                 feature_size=A,							sampling_rate=A,							padding_value=A,							**A,							)

             SCREAMING_SNAKE_CASE   :      str    					=						spectrogram_length
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						num_channels
             SCREAMING_SNAKE_CASE   :      List[str]    					=						patch_size
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						feature_size // self.patch_size[1]
             SCREAMING_SNAKE_CASE   :      Dict    					=						n_fft
             SCREAMING_SNAKE_CASE   :      Tuple    					=						sampling_rate // hop_length_to_sampling_rate
             SCREAMING_SNAKE_CASE   :      str    					=						sampling_rate
             SCREAMING_SNAKE_CASE   :      int    					=						padding_value
             SCREAMING_SNAKE_CASE   :      Any    					=						mel_filter_bank(
                 num_frequency_bins=1 + n_fft // 2,							num_mel_filters=A,							min_frequency=0.0,							max_frequency=2_20_50.0,							sampling_rate=A,							norm='slaney',							mel_scale='slaney',							).T







       def        UpperCamelCase_							(      self,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						spectrogram(
                 A,							window_function(self.n_fft,							'hann'  ),							frame_length=self.n_fft,							hop_length=self.hop_length,							power=2.0,							mel_filters=self.mel_filters.T,							log_mel='dB',							db_range=80.0,							)
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						log_spec[:, :-1]
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						log_spec - 20.0
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						np.clip(log_spec / 40.0,							-2.0,							0.0  ) + 1.0
             return log_spec







       def __call__(      self,							A,							A = None,							A = True,							A = None,							A = False,							A = False,							**A,							):







             '''simple docstring'''







             if sampling_rate is not None:
                   if sampling_rate != self.sampling_rate:
                         raise ValueError(
                             'This feature extractor is set to support sampling rate'
                             F" of {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled"
                             F" with {self.sampling_rate} and not {sampling_rate}."  )
             else:
                   logger.warning(
                       'It is strongly recommended to pass the `sampling_rate` argument to this function. '
                       'Failing to do so can result in silent errors that might be hard to debug.'  )

             SCREAMING_SNAKE_CASE   :      List[Any]    					=						isinstance(A,							np.ndarray  ) and len(raw_speech.shape  ) > 1
             if is_batched_numpy and len(raw_speech.shape  ) > 2:
                   raise ValueError(F"Only mono-channel audio is supported for input to {self}"  )
             SCREAMING_SNAKE_CASE   :      int    					=						is_batched_numpy or (
                 isinstance(A,							(list, tuple)  ) and (isinstance(raw_speech[0],							(np.ndarray, tuple, list)  ))
             )
             if is_batched:
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						[np.asarray([speech],							dtype=np.floataa  ).T for speech in raw_speech]
             elif not is_batched and not isinstance(A,							np.ndarray  ):
                   SCREAMING_SNAKE_CASE   :      Any    					=						np.asarray(A,							dtype=np.floataa  )
             elif isinstance(A,							np.ndarray  ) and raw_speech.dtype is np.dtype(np.floataa  ):
                   SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						raw_speech.astype(np.floataa  )
             # always return batch
             if not is_batched:
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						[np.asarray([raw_speech]  ).T]

             # Convert audio signals to log mel spectrograms, truncate by time axis
             SCREAMING_SNAKE_CASE   :      int    					=						[
                 self._np_extract_fbank_features(waveform.squeeze()  ).T[: self.spectrogram_length] for waveform in raw_speech
             ]
             if isinstance(audio_features[0],							A  ):
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						[np.asarray(A,							dtype=np.floataa  ) for feature in audio_features]

             # Create audio attention mask
             SCREAMING_SNAKE_CASE   :      Tuple    					=						max(
                 [ceil(feature.shape[0] / self.patch_size[0]  ) * self.freq_len for feature in audio_features]  )  # The maximum number of audio patches in a batch
             if return_attention_mask:
                   SCREAMING_SNAKE_CASE   :      List[Any]    					=						[
                       (ceil(feature.shape[0] / self.patch_size[0]  ) * self.freq_len) * [1]
                       + (max_patch_len - ceil(feature.shape[0] / self.patch_size[0]  ) * self.freq_len) * [0]
                       for feature in audio_features
                   ]
                   SCREAMING_SNAKE_CASE   :      Tuple    					=						np.array(A  ).astype(np.floataa  )

             # convert into correct format for padding
             SCREAMING_SNAKE_CASE   :      Tuple    					=						max_patch_len // self.freq_len * self.patch_size[0]  # The maximum audio size in a batch
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						np.ones([len(A  ), 1, max_time_len, self.feature_size]  ).astype(np.floataa  )
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						padded_audio_features * self.padding_value
             for i in range(len(A  )  ):
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						audio_features[i]
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						feature

             # return as BatchFeature
             if return_attention_mask:
                   SCREAMING_SNAKE_CASE   :      Any    					=						{'audio_values': padded_audio_features, 'audio_mask': audio_mask}
             else:
                   SCREAMING_SNAKE_CASE   :      Dict    					=						{'audio_values': padded_audio_features}

             SCREAMING_SNAKE_CASE   :      str    					=						BatchFeature(data=A,							tensor_type=A  )
             return encoded_inputs


