



import argparse
import gc
import os
import threading

import evaluate
import psutil
import torch
from datasets import load_dataset
from torch.distributed.fsdp.fully_sharded_data_parallel import FullOptimStateDictConfig, FullStateDictConfig
from torch.utils.data import DataLoader
from transformers import (
    AutoModelForSequenceClassification,
    AutoTokenizer,
    get_linear_schedule_with_warmup,
    set_seed,
)

from accelerate import Accelerator, DistributedType, FullyShardedDataParallelPlugin


########################################################################
# This is a fully working simple example to use Accelerate
#
# This example trains a Bert base model on GLUE MRPC
# in any of the following settings (with the same script):
#   - single CPU or single GPU
#   - multi GPUS (using PyTorch distributed mode)
#   - (multi) TPUs
#   - fp16 (mixed-precision) or fp32 (normal precision)
#   - FSDP
#
# This example also demonstrates the checkpointing and sharding capabilities
#
# To run it in each of these various modes, follow the instructions
# in the readme for examples:
# https://github.com/huggingface/accelerate/tree/main/examples
#
########################################################################


__A       =1_6
__A       =3_2

def 			a		( _UpperCAmelCase				:   List[str]		):







		'''simple docstring'''





		return int(x / 2**20		)

class 						UpperCAmelCase__     :




			'''simple docstring'''






			def __enter__(  self				:					Optional[int]					):
					'''simple docstring'''





					gc.collect()
					torch.cuda.empty_cache()
					torch.cuda.reset_max_memory_allocated()  # reset the peak gauge to zero
					__UpperCAmelCase       :	Union[str, Any]						=      torch.cuda.memory_allocated()
					__UpperCAmelCase       :	List[str]						=      psutil.Process()

					__UpperCAmelCase       :	Optional[Any]						=      self.cpu_mem_used()
					__UpperCAmelCase       :	int						=      True
					__UpperCAmelCase       :	Tuple						=      threading.Thread(target=self.peak_monitor_func					)
					__UpperCAmelCase       :	Any						=      True
					peak_monitor_thread.start()
					return self




			def 					snake_case__	(  self				:					Any					):
					'''simple docstring'''





					return self.process.memory_info().rss




			def 					snake_case__	(  self				:					Tuple					):
					'''simple docstring'''





					__UpperCAmelCase       :	Any						=      -1

					while True:
							__UpperCAmelCase       :	Optional[Any]						=      max(self.cpu_mem_used()			,			self.cpu_peak					)

							# can't sleep or will not catch the peak right (this comment is here on purpose)
							# time.sleep(0.001) # 1msec

							if not self.peak_monitoring:
									break




			def __exit__(  self				:					Union[str, Any]			,			*a_				:					int					):
					'''simple docstring'''





					__UpperCAmelCase       :	int						=      False

					gc.collect()
					torch.cuda.empty_cache()
					__UpperCAmelCase       :	Union[str, Any]						=      torch.cuda.memory_allocated()
					__UpperCAmelCase       :	Any						=      torch.cuda.max_memory_allocated()
					__UpperCAmelCase       :	Optional[int]						=      bamb(self.end - self.begin					)
					__UpperCAmelCase       :	List[str]						=      bamb(self.peak - self.begin					)

					__UpperCAmelCase       :	int						=      self.cpu_mem_used()
					__UpperCAmelCase       :	Union[str, Any]						=      bamb(self.cpu_end - self.cpu_begin					)
					__UpperCAmelCase       :	Any						=      bamb(self.cpu_peak - self.cpu_begin					)
					# print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")


# For testing only
if os.environ.get("TESTING_MOCKED_DATALOADERS", None) == "1":
				from accelerate.test_utils.training import mocked_dataloaders

				__A       =mocked_dataloaders  # noqa: F811

def 			a		( _UpperCAmelCase				:   int					,  _UpperCAmelCase				:   str		):







		'''simple docstring'''





		if os.environ.get('''TESTING_MOCKED_DATALOADERS'''					,  _UpperCAmelCase		) == "1":
				__UpperCAmelCase       :	List[str]						=      2

		# New Code #
		# Pass the advanced FSDP settings not part of the accelerate config by creating fsdp_plugin
		__UpperCAmelCase       :	List[str]						=      FullyShardedDataParallelPlugin(
		    state_dict_config=FullStateDictConfig(offload_to_cpu=_UpperCAmelCase					,  ranka_only=_UpperCAmelCase		)					,  optim_state_dict_config=FullOptimStateDictConfig(offload_to_cpu=_UpperCAmelCase					,  ranka_only=_UpperCAmelCase		)					,  )

		# Initialize accelerator
		if args.with_tracking:
				__UpperCAmelCase       :	Union[str, Any]						=      Accelerator(
				    cpu=args.cpu					,  mixed_precision=args.mixed_precision					,  log_with='''wandb'''					,  project_dir=args.logging_dir					,  fsdp_plugin=_UpperCAmelCase					,  )
		else:
				__UpperCAmelCase       :	Union[str, Any]						=      Accelerator(fsdp_plugin=_UpperCAmelCase		)
		accelerator.print(accelerator.distributed_type		)

		if hasattr(args.checkpointing_steps					,  '''isdigit'''		):
				if args.checkpointing_steps == "epoch":
						__UpperCAmelCase       :	List[Any]						=      args.checkpointing_steps
				elif args.checkpointing_steps.isdigit():
						__UpperCAmelCase       :	List[Any]						=      int(args.checkpointing_steps		)
				else:
						raise ValueError(
						    f'Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.'		)
		else:
				__UpperCAmelCase       :	Optional[int]						=      None
		# Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
		__UpperCAmelCase       :	Optional[int]						=      config['''lr''']
		__UpperCAmelCase       :	Dict						=      int(config['''num_epochs''']		)
		__UpperCAmelCase       :	Optional[int]						=      int(config['''seed''']		)
		__UpperCAmelCase       :	int						=      int(config['''batch_size''']		)

		# We need to initialize the trackers we use, and also store our configuration
		if args.with_tracking:
				__UpperCAmelCase       :	int						=      vars(_UpperCAmelCase		)
				accelerator.init_trackers('''fsdp_glue_no_trainer'''					,  _UpperCAmelCase		)

		__UpperCAmelCase       :	List[str]						=      AutoTokenizer.from_pretrained(args.model_name_or_path		)
		__UpperCAmelCase       :	Optional[int]						=      load_dataset('''glue'''					,  '''mrpc'''		)
		__UpperCAmelCase       :	Union[str, Any]						=      evaluate.load('''glue'''					,  '''mrpc'''		)

		def tokenize_function(_UpperCAmelCase				:   str		):
				# max_length=None => use the model max length (it's actually the default)
				__UpperCAmelCase       :	Optional[Any]						=      tokenizer(examples['''sentence1''']					,  examples['''sentence2''']					,  truncation=_UpperCAmelCase					,  max_length=_UpperCAmelCase		)
				return outputs

		# Apply the method we just defined to all the examples in all the splits of the dataset
		# starting with the main process first:
		with accelerator.main_process_first():
				__UpperCAmelCase       :	Optional[int]						=      datasets.map(
				    _UpperCAmelCase					,  batched=_UpperCAmelCase					,  remove_columns=['''idx''', '''sentence1''', '''sentence2''']					,  )

		# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
		# transformers library
		__UpperCAmelCase       :	int						=      tokenized_datasets.rename_column('''label'''					,  '''labels'''		)

		# If the batch size is too big we use gradient accumulation
		__UpperCAmelCase       :	List[Any]						=      1
		if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU:
				__UpperCAmelCase       :	Tuple						=      batch_size // MAX_GPU_BATCH_SIZE
				__UpperCAmelCase       :	Optional[Any]						=      MAX_GPU_BATCH_SIZE

		def collate_fn(_UpperCAmelCase				:   List[Any]		):
				# On TPU it's best to pad everything to the same length or training will be very slow.
				__UpperCAmelCase       :	Union[str, Any]						=      1_28 if accelerator.distributed_type == DistributedType.TPU else None
				# When using mixed precision we want round multiples of 8/16
				if accelerator.mixed_precision == "fp8":
						__UpperCAmelCase       :	int						=      16
				elif accelerator.mixed_precision != "no":
						__UpperCAmelCase       :	str						=      8
				else:
						__UpperCAmelCase       :	List[str]						=      None

				return tokenizer.pad(
				    _UpperCAmelCase					,  padding='''longest'''					,  max_length=_UpperCAmelCase					,  pad_to_multiple_of=_UpperCAmelCase					,  return_tensors='''pt'''					,  )

		# Instantiate dataloaders.
		__UpperCAmelCase       :	str						=      DataLoader(
		    tokenized_datasets['''train''']					,  shuffle=_UpperCAmelCase					,  collate_fn=_UpperCAmelCase					,  batch_size=_UpperCAmelCase		)
		__UpperCAmelCase       :	int						=      DataLoader(
		    tokenized_datasets['''validation''']					,  shuffle=_UpperCAmelCase					,  collate_fn=_UpperCAmelCase					,  batch_size=_UpperCAmelCase		)

		set_seed(_UpperCAmelCase		)

		# Instantiate the model (we build the model here so that the seed also control new weights initialization)
		__UpperCAmelCase       :	Union[str, Any]						=      AutoModelForSequenceClassification.from_pretrained(
		    args.model_name_or_path					,  return_dict=_UpperCAmelCase					,  low_cpu_mem_usage=_UpperCAmelCase		)

		# New Code #
		# For FSDP feature, it is highly recommended and efficient to prepare the model before creating optimizer
		__UpperCAmelCase       :	Optional[Any]						=      accelerator.prepare(_UpperCAmelCase		)
		accelerator.print(_UpperCAmelCase		)

		# Instantiate optimizer
		# New Code #
		# For FSDP feature, at present it doesn't support multiple parameter groups,
		# so we need to create a single parameter group for the whole model
		__UpperCAmelCase       :	Dict						=      torch.optim.AdamW(params=model.parameters()					,  lr=_UpperCAmelCase					,  weight_decay=2e-4		)

		# Instantiate scheduler
		__UpperCAmelCase       :	List[str]						=      get_linear_schedule_with_warmup(
		    optimizer=_UpperCAmelCase					,  num_warmup_steps=10					,  num_training_steps=(len(_UpperCAmelCase		) * num_epochs) // gradient_accumulation_steps					,  )

		# New Code #
		# For FSDP feature, prepare everything except the model as we have already prepared the model
		# before creating the optimizer
		# There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
		# prepare method.
		__UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase       :	Optional[int]						=      accelerator.prepare(
		    _UpperCAmelCase					,  _UpperCAmelCase					,  _UpperCAmelCase					,  _UpperCAmelCase		)

		__UpperCAmelCase       :	List[str]						=      0

		# Potentially load in the weights and states from a previous save
		if args.resume_from_checkpoint:
				if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
						accelerator.print(f'Resumed from checkpoint: {args.resume_from_checkpoint}'		)
						accelerator.load_state(args.resume_from_checkpoint		)
						__UpperCAmelCase       :	List[str]						=      os.path.basename(args.resume_from_checkpoint		)
				else:
						# Get the most recent checkpoint
						__UpperCAmelCase       :	Any						=      [f.name for f in os.scandir(os.getcwd()		) if f.is_dir()]
						dirs.sort(key=os.path.getctime		)
						__UpperCAmelCase       :	Union[str, Any]						=      dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
				# Extract `epoch_{i}` or `step_{i}`
				__UpperCAmelCase       :	Optional[Any]						=      os.path.splitext(_UpperCAmelCase		)[0]

				if "epoch" in training_difference:
						num_epochs -= int(training_difference.replace('''epoch_'''					,  ''''''		)		)
						__UpperCAmelCase       :	Dict						=      None
				else:
						__UpperCAmelCase       :	List[str]						=      int(training_difference.replace('''step_'''					,  ''''''		)		)
						num_epochs -= resume_step // len(_UpperCAmelCase		)
						# If resuming by step, we also need to know exactly how far into the DataLoader we went
						__UpperCAmelCase       :	Optional[Any]						=      (num_epochs * len(_UpperCAmelCase		)) - resume_step

    # Now we train the model
		for epoch in range(_UpperCAmelCase		):
				# New Code #
				# context manager to track the peak memory usage during the training epoch
				with TorchTracemalloc() as tracemalloc:
						model.train()
						if args.with_tracking:
								__UpperCAmelCase       :	Dict						=      0
						for step, batch in enumerate(_UpperCAmelCase		):
								# We need to skip steps until we reach the resumed step
								if args.resume_from_checkpoint and epoch == 0:
										if resume_step is not None and step < resume_step:
												pass
                # We could avoid this line since we set the accelerator with `device_placement=True`.
								batch.to(accelerator.device		)
								__UpperCAmelCase       :	Dict						=      model(**_UpperCAmelCase		)
								__UpperCAmelCase       :	int						=      outputs.loss
								__UpperCAmelCase       :	Any						=      loss / gradient_accumulation_steps
								# We keep track of the loss at each epoch
								if args.with_tracking:
										total_loss += loss.detach().float()
								accelerator.backward(_UpperCAmelCase		)
								if step % gradient_accumulation_steps == 0:
										optimizer.step()
										lr_scheduler.step()
										optimizer.zero_grad()
										# accelerator.print(lr_scheduler.get_lr())

								overall_step += 1

								if isinstance(_UpperCAmelCase					,  _UpperCAmelCase		):
										__UpperCAmelCase       :	Dict						=      f'step_{overall_step}'
										if overall_step % checkpointing_steps == 0:
												if args.output_dir is not None:
														__UpperCAmelCase       :	Union[str, Any]						=      os.path.join(args.output_dir					,  _UpperCAmelCase		)
												accelerator.save_state(_UpperCAmelCase		)
        # New Code #
        # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage
				accelerator.print('''Memory before entering the train : {}'''.format(bamb(tracemalloc.begin		)		)		)
				accelerator.print('''Memory consumed at the end of the train (end-begin): {}'''.format(tracemalloc.used		)		)
				accelerator.print('''Peak Memory consumed during the train (max-begin): {}'''.format(tracemalloc.peaked		)		)
				accelerator.print(
				    '''Total Peak Memory consumed during the train (max): {}'''.format(
				        tracemalloc.peaked + bamb(tracemalloc.begin		)		)		)
				# Logging the peak memory usage of the GPU to the tracker
				if args.with_tracking:
						accelerator.log(
						    {
						        '''train_total_peak_memory''': tracemalloc.peaked + bamb(tracemalloc.begin		),
						    }					,  step=_UpperCAmelCase					,  )

				# New Code #
				# context manager to track the peak memory usage during the evaluation
				with TorchTracemalloc() as tracemalloc:
						model.eval()
						for step, batch in enumerate(_UpperCAmelCase		):
								# We could avoid this line since we set the accelerator with `device_placement=True`.
								batch.to(accelerator.device		)
								with torch.no_grad():
										__UpperCAmelCase       :	List[Any]						=      model(**_UpperCAmelCase		)
								__UpperCAmelCase       :	Tuple						=      outputs.logits.argmax(dim=-1		)
								__UpperCAmelCase				,   __UpperCAmelCase       :	List[str]						=      accelerator.gather_for_metrics((predictions, batch['''labels'''])		)
								metric.add_batch(
								    predictions=_UpperCAmelCase					,  references=_UpperCAmelCase					,  )

						__UpperCAmelCase       :	str						=      metric.compute()
						# Use accelerator.print to print only on the main process.
						accelerator.print(f'epoch {epoch}:'					,  _UpperCAmelCase		)
						if args.with_tracking:
								accelerator.log(
								    {
								        '''accuracy''': eval_metric['''accuracy'''],
								        '''f1''': eval_metric['''f1'''],
								        '''train_loss''': total_loss.item() / len(_UpperCAmelCase		),
								    }					,  step=_UpperCAmelCase					,  )

						if checkpointing_steps == "epoch":
								__UpperCAmelCase       :	List[Any]						=      f'epoch_{epoch}'
								if args.output_dir is not None:
										__UpperCAmelCase       :	Tuple						=      os.path.join(args.output_dir					,  _UpperCAmelCase		)
								accelerator.save_state(_UpperCAmelCase		)
        # New Code #
        # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage
				accelerator.print('''Memory before entering the eval : {}'''.format(bamb(tracemalloc.begin		)		)		)
				accelerator.print('''Memory consumed at the end of the eval (end-begin): {}'''.format(tracemalloc.used		)		)
				accelerator.print('''Peak Memory consumed during the eval (max-begin): {}'''.format(tracemalloc.peaked		)		)
				accelerator.print(
				    '''Total Peak Memory consumed during the eval (max): {}'''.format(tracemalloc.peaked + bamb(tracemalloc.begin		)		)		)
				# Logging the peak memory usage of the GPU to the tracker
				if args.with_tracking:
						accelerator.log(
						    {
						        '''eval_total_peak_memory''': tracemalloc.peaked + bamb(tracemalloc.begin		),
						    }					,  step=_UpperCAmelCase					,  )

		if args.with_tracking:
				accelerator.end_training()

def 			a		( ):







		'''simple docstring'''





		__UpperCAmelCase       :	Optional[int]						=      argparse.ArgumentParser(description='''Simple example of training script.'''		)
		parser.add_argument(
		    '''--mixed_precision'''					,  type=_UpperCAmelCase					,  default=_UpperCAmelCase					,  choices=['''no''', '''fp16''', '''bf16''', '''fp8''']					,  help='''Whether to use mixed precision. Choose'''
		    '''between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.'''
		    '''and an Nvidia Ampere GPU.'''					,  )
		parser.add_argument('''--cpu'''					,  action='''store_true'''					,  help='''If passed, will train on the CPU.'''		)
		parser.add_argument(
		    '''--checkpointing_steps'''					,  type=_UpperCAmelCase					,  default=_UpperCAmelCase					,  help='''Whether the various states should be saved at the end of every n steps, or \'epoch\' for each epoch.'''					,  )
		parser.add_argument(
		    '''--resume_from_checkpoint'''					,  type=_UpperCAmelCase					,  default=_UpperCAmelCase					,  help='''If the training should continue from a checkpoint folder.'''					,  )
		parser.add_argument(
		    '''--with_tracking'''					,  action='''store_true'''					,  help='''Whether to load in all available experiment trackers from the environment and use them for logging.'''					,  )
		parser.add_argument(
		    '''--output_dir'''					,  type=_UpperCAmelCase					,  default='''.'''					,  help='''Optional save directory where all checkpoint folders will be stored. Default is the current working directory.'''					,  )
		parser.add_argument(
		    '''--logging_dir'''					,  type=_UpperCAmelCase					,  default='''logs'''					,  help='''Location on where to store experiment tracking logs`'''					,  )
		parser.add_argument(
		    '''--model_name_or_path'''					,  type=_UpperCAmelCase					,  help='''Path to pretrained model or model identifier from huggingface.co/models.'''					,  required=_UpperCAmelCase					,  )
		__UpperCAmelCase       :	Dict						=      parser.parse_args()
		__UpperCAmelCase       :	Tuple						=      {'''lr''': 2e-5, '''num_epochs''': 3, '''seed''': 42, '''batch_size''': 16}
		training_function(_UpperCAmelCase					,  _UpperCAmelCase		)


if __name__ == "__main__":
				main()










import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
				from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

				from .test_feature_extraction_speechta import floats_list


__A       =get_tests_dir("fixtures/test_sentencepiece_bpe_char.model")

@require_torch
class 						UpperCAmelCase__     (     unittest.TestCase  ):




			'''simple docstring'''






			def 					snake_case__	(  self				:					List[str]					):
					'''simple docstring'''





					__UpperCAmelCase       :	str						=      tempfile.mkdtemp()

					__UpperCAmelCase       :	Optional[int]						=      SpeechTaTokenizer(a_					)
					tokenizer.save_pretrained(self.tmpdirname					)

					__UpperCAmelCase       :	Union[str, Any]						=      {
					    '''feature_size''': 1,
					    '''padding_value''': 0.0,
					    '''sampling_rate''': 1_60_00,
					    '''do_normalize''': False,
					    '''num_mel_bins''': 80,
					    '''hop_length''': 16,
					    '''win_length''': 64,
					    '''win_function''': '''hann_window''',
					    '''fmin''': 80,
					    '''fmax''': 76_00,
					    '''mel_floor''': 1e-10,
					    '''reduction_factor''': 2,
					    '''return_attention_mask''': True,
					}

					__UpperCAmelCase       :	Tuple						=      os.path.join(self.tmpdirname			,			a_					)
					with open(self.feature_extraction_file			,			'''w'''			,			encoding='''utf-8'''					) as fp:
							fp.write(json.dumps(a_					) + '''\n'''					)




			def 					snake_case__	(  self				:					Any			,			**a_				:					Tuple					):
					'''simple docstring'''





					return SpeechTaTokenizer.from_pretrained(self.tmpdirname			,			**a_					)




			def 					snake_case__	(  self				:					Dict			,			**a_				:					str					):
					'''simple docstring'''





					return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname			,			**a_					)




			def 					snake_case__	(  self				:					List[str]					):
					'''simple docstring'''





					shutil.rmtree(self.tmpdirname					)




			def 					snake_case__	(  self				:					Dict					):
					'''simple docstring'''





					__UpperCAmelCase       :	int						=      self.get_tokenizer()
					__UpperCAmelCase       :	str						=      self.get_feature_extractor()

					__UpperCAmelCase       :	List[Any]						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					processor.save_pretrained(self.tmpdirname					)
					__UpperCAmelCase       :	List[str]						=      SpeechTaProcessor.from_pretrained(self.tmpdirname					)

					self.assertEqual(processor.tokenizer.get_vocab()			,			tokenizer.get_vocab()					)
					self.assertIsInstance(processor.tokenizer			,			a_					)

					self.assertEqual(processor.feature_extractor.to_json_string()			,			feature_extractor.to_json_string()					)
					self.assertIsInstance(processor.feature_extractor			,			a_					)




			def 					snake_case__	(  self				:					int					):
					'''simple docstring'''





					__UpperCAmelCase       :	Optional[int]						=      SpeechTaProcessor(tokenizer=self.get_tokenizer()			,			feature_extractor=self.get_feature_extractor()					)
					processor.save_pretrained(self.tmpdirname					)

					__UpperCAmelCase       :	Optional[Any]						=      self.get_tokenizer(bos_token='''(BOS)'''			,			eos_token='''(EOS)'''					)
					__UpperCAmelCase       :	List[Any]						=      self.get_feature_extractor(do_normalize=a_			,			padding_value=1.0					)

					__UpperCAmelCase       :	List[str]						=      SpeechTaProcessor.from_pretrained(
					    self.tmpdirname			,			bos_token='''(BOS)'''			,			eos_token='''(EOS)'''			,			do_normalize=a_			,			padding_value=1.0					)

					self.assertEqual(processor.tokenizer.get_vocab()			,			tokenizer_add_kwargs.get_vocab()					)
					self.assertIsInstance(processor.tokenizer			,			a_					)

					self.assertEqual(processor.feature_extractor.to_json_string()			,			feature_extractor_add_kwargs.to_json_string()					)
					self.assertIsInstance(processor.feature_extractor			,			a_					)




			def 					snake_case__	(  self				:					Union[str, Any]					):
					'''simple docstring'''





					__UpperCAmelCase       :	Optional[Any]						=      self.get_feature_extractor()
					__UpperCAmelCase       :	Union[str, Any]						=      self.get_tokenizer()

					__UpperCAmelCase       :	List[Any]						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					__UpperCAmelCase       :	List[Any]						=      floats_list((3, 10_00)					)

					__UpperCAmelCase       :	Tuple						=      feature_extractor(audio=a_			,			return_tensors='''np'''					)
					__UpperCAmelCase       :	List[str]						=      processor(audio=a_			,			return_tensors='''np'''					)

					for key in input_feat_extract.keys():
							self.assertAlmostEqual(input_feat_extract[key].sum()			,			input_processor[key].sum()			,			delta=1e-2					)




			def 					snake_case__	(  self				:					Optional[Any]					):
					'''simple docstring'''





					__UpperCAmelCase       :	List[Any]						=      self.get_feature_extractor()
					__UpperCAmelCase       :	Dict						=      self.get_tokenizer()

					__UpperCAmelCase       :	Optional[Any]						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					__UpperCAmelCase       :	Union[str, Any]						=      floats_list((3, 10_00)					)

					__UpperCAmelCase       :	Dict						=      feature_extractor(audio_target=a_			,			return_tensors='''np'''					)
					__UpperCAmelCase       :	str						=      processor(audio_target=a_			,			return_tensors='''np'''					)

					for key in input_feat_extract.keys():
							self.assertAlmostEqual(input_feat_extract[key].sum()			,			input_processor[key].sum()			,			delta=1e-2					)




			def 					snake_case__	(  self				:					Union[str, Any]					):
					'''simple docstring'''





					__UpperCAmelCase       :	Union[str, Any]						=      self.get_feature_extractor()
					__UpperCAmelCase       :	Optional[int]						=      self.get_tokenizer()

					__UpperCAmelCase       :	Optional[Any]						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					__UpperCAmelCase       :	List[str]						=      '''This is a test string'''

					__UpperCAmelCase       :	List[Any]						=      processor(text=a_					)
					__UpperCAmelCase       :	Optional[int]						=      tokenizer(a_					)

					for key in encoded_tok.keys():
							self.assertListEqual(encoded_tok[key]			,			encoded_processor[key]					)




			def 					snake_case__	(  self				:					List[str]					):
					'''simple docstring'''





					__UpperCAmelCase       :	Optional[Any]						=      self.get_feature_extractor()
					__UpperCAmelCase       :	Optional[Any]						=      self.get_tokenizer()

					__UpperCAmelCase       :	List[Any]						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					__UpperCAmelCase       :	List[str]						=      '''This is a test string'''

					__UpperCAmelCase       :	Optional[Any]						=      processor(text_target=a_					)
					__UpperCAmelCase       :	Optional[int]						=      tokenizer(a_					)

					for key in encoded_tok.keys():
							self.assertListEqual(encoded_tok[key]			,			encoded_processor[key]					)




			def 					snake_case__	(  self				:					List[str]					):
					'''simple docstring'''





					__UpperCAmelCase       :	int						=      self.get_feature_extractor()
					__UpperCAmelCase       :	Union[str, Any]						=      self.get_tokenizer()

					__UpperCAmelCase       :	int						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					__UpperCAmelCase       :	Optional[Any]						=      [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

					__UpperCAmelCase       :	Optional[Any]						=      processor.batch_decode(a_					)
					__UpperCAmelCase       :	Any						=      tokenizer.batch_decode(a_					)

					self.assertListEqual(a_			,			a_					)




			def 					snake_case__	(  self				:					str					):
					'''simple docstring'''





					__UpperCAmelCase       :	str						=      self.get_feature_extractor()
					__UpperCAmelCase       :	str						=      self.get_tokenizer()

					__UpperCAmelCase       :	Optional[Any]						=      SpeechTaProcessor(tokenizer=a_			,			feature_extractor=a_					)

					self.assertListEqual(
					    processor.model_input_names			,			feature_extractor.model_input_names			,			msg='''`processor` and `feature_extractor` model input names do not match'''			,			)





