code: 
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import shutil
  import tempfile
  import unittest
  
  import pytest
  
  from transformers import WhisperTokenizer, is_speech_available
  from transformers.testing_utils import require_sentencepiece, require_torch, require_torchaudio
  
  from .test_feature_extraction_whisper import floats_list
  
  
  if is_speech_available():
  	from transformers import WhisperFeatureExtractor, WhisperProcessor
  
  
  _a      :				Optional[int]											=					5_0_3_5_8
  _a      :				List[str]											=					5_0_3_6_2
  
  
  
  
  
  @require_torch
  @require_torchaudio
  @require_sentencepiece
  class 					_UpperCAmelCase							(		unittest.TestCase     ):
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       """openai/whisper-small.en"""
  					__lowerCAmelCase      		=       tempfile.mkdtemp()
  		def 						lowerCamelCase__    (						self,**__SCREAMING_SNAKE_CASE    ):
  
  
  
  					'''simple docstring'''
  
  					return WhisperTokenizer.from_pretrained(self.checkpoint,**__SCREAMING_SNAKE_CASE    )
  		def 						lowerCamelCase__    (						self,**__SCREAMING_SNAKE_CASE    ):
  
  
  
  					'''simple docstring'''
  
  					return WhisperFeatureExtractor.from_pretrained(self.checkpoint,**__SCREAMING_SNAKE_CASE    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					shutil.rmtree(self.tmpdirname    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       self.get_tokenizer()
  					__lowerCAmelCase      		=       self.get_feature_extractor()
  
  					__lowerCAmelCase      		=       WhisperProcessor(tokenizer=__SCREAMING_SNAKE_CASE,feature_extractor=__SCREAMING_SNAKE_CASE    )
  
  					processor.save_pretrained(self.tmpdirname    )
  					__lowerCAmelCase      		=       WhisperProcessor.from_pretrained(self.tmpdirname    )
  
  					self.assertEqual(processor.tokenizer.get_vocab(),tokenizer.get_vocab()    )
  					self.assertIsInstance(processor.tokenizer,__SCREAMING_SNAKE_CASE    )
  
  					self.assertEqual(processor.feature_extractor.to_json_string(),feature_extractor.to_json_string()    )
  					self.assertIsInstance(processor.feature_extractor,__SCREAMING_SNAKE_CASE    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       WhisperProcessor(tokenizer=self.get_tokenizer(),feature_extractor=self.get_feature_extractor()    )
  					processor.save_pretrained(self.tmpdirname    )
  
  					__lowerCAmelCase      		=       self.get_tokenizer(bos_token="""(BOS)""",eos_token="""(EOS)"""    )
  					__lowerCAmelCase      		=       self.get_feature_extractor(do_normalize=__SCREAMING_SNAKE_CASE,padding_value=1.0    )
  
  					__lowerCAmelCase      		=       WhisperProcessor.from_pretrained(
  					    self.tmpdirname,bos_token="""(BOS)""",eos_token="""(EOS)""",do_normalize=__SCREAMING_SNAKE_CASE,padding_value=1.0    )
  
  					self.assertEqual(processor.tokenizer.get_vocab(),tokenizer_add_kwargs.get_vocab()    )
  					self.assertIsInstance(processor.tokenizer,__SCREAMING_SNAKE_CASE    )
  
  					self.assertEqual(processor.feature_extractor.to_json_string(),feature_extractor_add_kwargs.to_json_string()    )
  					self.assertIsInstance(processor.feature_extractor,__SCREAMING_SNAKE_CASE    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       self.get_feature_extractor()
  					__lowerCAmelCase      		=       self.get_tokenizer()
  
  					__lowerCAmelCase      		=       WhisperProcessor(tokenizer=__SCREAMING_SNAKE_CASE,feature_extractor=__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase      		=       floats_list((3, 10_00)    )
  
  					__lowerCAmelCase      		=       feature_extractor(__SCREAMING_SNAKE_CASE,return_tensors="""np"""    )
  					__lowerCAmelCase      		=       processor(__SCREAMING_SNAKE_CASE,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 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       self.get_feature_extractor()
  					__lowerCAmelCase      		=       self.get_tokenizer()
  
  					__lowerCAmelCase      		=       WhisperProcessor(tokenizer=__SCREAMING_SNAKE_CASE,feature_extractor=__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase      		=       """This is a test string"""
  
  					__lowerCAmelCase      		=       processor(text=__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase      		=       tokenizer(__SCREAMING_SNAKE_CASE    )
  
  					for key in encoded_tok.keys():
  								self.assertListEqual(encoded_tok[key],encoded_processor[key]    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       self.get_feature_extractor()
  					__lowerCAmelCase      		=       self.get_tokenizer()
  
  					__lowerCAmelCase      		=       WhisperProcessor(tokenizer=__SCREAMING_SNAKE_CASE,feature_extractor=__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase      		=       [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]
  
  					__lowerCAmelCase      		=       processor.batch_decode(__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       tokenizer.batch_decode(__SCREAMING_SNAKE_CASE    )
  
  					self.assertListEqual(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       self.get_feature_extractor()
  					__lowerCAmelCase      		=       self.get_tokenizer()
  
  					__lowerCAmelCase      		=       WhisperProcessor(tokenizer=__SCREAMING_SNAKE_CASE,feature_extractor=__SCREAMING_SNAKE_CASE    )
  
  					self.assertListEqual(
  					    processor.model_input_names,feature_extractor.model_input_names,msg="""`processor` and `feature_extractor` model input names do not match""",)
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       self.get_feature_extractor()
  					__lowerCAmelCase      		=       self.get_tokenizer()
  
  					__lowerCAmelCase      		=       WhisperProcessor(tokenizer=__SCREAMING_SNAKE_CASE,feature_extractor=__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       processor.get_decoder_prompt_ids(task="""transcribe""",no_timestamps=__SCREAMING_SNAKE_CASE    )
  
  					self.assertIsInstance(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    )
  					for ids in forced_decoder_ids:
  								self.assertIsInstance(__SCREAMING_SNAKE_CASE,(list, tuple)    )
  
  					__lowerCAmelCase      		=       [TRANSCRIBE, NOTIMESTAMPS]
  					self.assertListEqual([ids[-1] for ids in forced_decoder_ids],__SCREAMING_SNAKE_CASE    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       WhisperProcessor(tokenizer=self.get_tokenizer(),feature_extractor=self.get_feature_extractor()    )
  					__lowerCAmelCase      		=       processor.get_prompt_ids("""Mr. Quilter"""    )
  					__lowerCAmelCase      		=       processor.tokenizer.decode(__SCREAMING_SNAKE_CASE    )
  
  					self.assertListEqual(prompt_ids.tolist(),[5_03_60, 17_70, 13, 22_64, 3_46, 3_53]    )
  					self.assertEqual(__SCREAMING_SNAKE_CASE,"""<|startofprev|> Mr. Quilter"""    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       WhisperProcessor(tokenizer=self.get_tokenizer(),feature_extractor=self.get_feature_extractor()    )
  					__lowerCAmelCase      		=       processor.get_prompt_ids(""""""    )
  					__lowerCAmelCase      		=       processor.tokenizer.decode(__SCREAMING_SNAKE_CASE    )
  
  					self.assertListEqual(prompt_ids.tolist(),[5_03_60, 2_20]    )
  					self.assertEqual(__SCREAMING_SNAKE_CASE,"""<|startofprev|> """    )
  
  
  
  
  
  
  
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       WhisperProcessor(tokenizer=self.get_tokenizer(),feature_extractor=self.get_feature_extractor()    )
  
  					def _test_prompt_error_raised_helper(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    ):
  								with pytest.raises(__SCREAMING_SNAKE_CASE    ) as excinfo:
  											processor.get_prompt_ids(__SCREAMING_SNAKE_CASE    )
  								__lowerCAmelCase      		=       f'Encountered text in the prompt corresponding to disallowed special token: {special_token}.'
  								self.assertEqual(__SCREAMING_SNAKE_CASE,str(excinfo.value    )    )
  
  					_test_prompt_error_raised_helper("""<|startofprev|> test""","""<|startofprev|>"""    )
  					_test_prompt_error_raised_helper("""test <|notimestamps|>""","""<|notimestamps|>"""    )
  					_test_prompt_error_raised_helper("""test <|zh|> test <|transcribe|>""","""<|zh|>"""    )
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import os
  import sys
  from pathlib import Path
  
  import torch
  
  from transformers.testing_utils import TestCasePlus, execute_subprocess_async, require_torch_multi_gpu
  from utils import load_json
  
  
  _a      :				Optional[Any]											=					torch.cuda.is_available()
  _a      :				Dict											=					[""" Sam ate lunch today.""", """Sams lunch ingredients."""]
  _a      :				str											=					["""A very interesting story about what I ate for lunch.""", """Avocado, celery, turkey, coffee"""]
  _a      :				Optional[Any]											=					{
      """max_tokens_per_batch""": None,
      """supervise_forward""": True,
      """normalize_hidden""": True,
      """label_smoothing""": 0.2,
      """eval_max_gen_length""": None,
      """eval_beams""": 1,
      """val_metric""": """loss""",
      """save_top_k""": 1,
      """adafactor""": True,
      """early_stopping_patience""": 2,
      """logger_name""": """default""",
      """length_penalty""": 0.5,
      """cache_dir""": """""",
      """task""": """summarization""",
      """num_workers""": 2,
      """alpha_hid""": 0,
      """freeze_embeds""": True,
      """enc_only""": False,
      """tgt_suffix""": """""",
      """resume_from_checkpoint""": None,
      """sortish_sampler""": True,
      """student_decoder_layers""": 1,
      """val_check_interval""": 1.0,
      """output_dir""": """""",
      """fp16""": False,  # TODO(SS): set this to CUDA_AVAILABLE if ci installs apex or start using native amp
      """no_teacher""": False,
      """fp16_opt_level""": """O1""",
      """gpus""": 1 if CUDA_AVAILABLE else 0,
      """n_tpu_cores""": 0,
      """max_grad_norm""": 1.0,
      """do_train""": True,
      """do_predict""": True,
      """accumulate_grad_batches""": 1,
      """server_ip""": """""",
      """server_port""": """""",
      """seed""": 4_2,
      """model_name_or_path""": """sshleifer/bart-tiny-random""",
      """config_name""": """""",
      """tokenizer_name""": """facebook/bart-large""",
      """do_lower_case""": False,
      """learning_rate""": 0.3,
      """lr_scheduler""": """linear""",
      """weight_decay""": 0.0,
      """adam_epsilon""": 1E-08,
      """warmup_steps""": 0,
      """max_epochs""": 1,
      """train_batch_size""": 2,
      """eval_batch_size""": 2,
      """max_source_length""": 1_2,
      """max_target_length""": 1_2,
      """val_max_target_length""": 1_2,
      """test_max_target_length""": 1_2,
      """fast_dev_run""": False,
      """no_cache""": False,
      """n_train""": -1,
      """n_val""": -1,
      """n_test""": -1,
      """student_encoder_layers""": 1,
      """freeze_encoder""": False,
      """auto_scale_batch_size""": False,
      """overwrite_output_dir""": False,
      """student""": None,
  }
  
  
  
  
  
  def      _lowerCAmelCase		(		lowercase      ,			lowercase			)      ->      Any:
  			__lowerCAmelCase      		=       """\n""".join(lowercase			)
  			Path(lowercase			).open("""w"""			).writelines(lowercase			)
  
  
  
  
  
  def      _lowerCAmelCase		(		lowercase			)      ->      Optional[int]:
  			for split in ["train", "val", "test"]:
  						_dump_articles(os.path.join(lowercase      ,			f'{split}.source'			)      ,			lowercase			)
  						_dump_articles(os.path.join(lowercase      ,			f'{split}.target'			)      ,			lowercase			)
  			return tmp_dir
  
  
  
  
  
  
  
  class 					_UpperCAmelCase							(		lowerCAmelCase_     ):
  		@classmethod
  		def 						lowerCamelCase__    (						cls    ):
  
  
  
  					'''simple docstring'''
  
  					return cls
  		@require_torch_multi_gpu
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       {
  					    """no_teacher""": True,
  					    """freeze_encoder""": True,
  					    """gpus""": 2,
  					    """overwrite_output_dir""": True,
  					    """sortish_sampler""": True,
  					}
  					self._test_distiller_cli_fork(__SCREAMING_SNAKE_CASE,check_contents=__SCREAMING_SNAKE_CASE    )
  
  
  
  
  
  
  
  		def 						lowerCamelCase__    (						self,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE=True    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       {
  					    """label_smoothing""": 0.0,
  					    """early_stopping_patience""": -1,
  					    """train_batch_size""": 1,
  					    """eval_batch_size""": 2,
  					    """max_epochs""": 2,
  					    """alpha_mlm""": 0.2,
  					    """alpha_ce""": 0.8,
  					    """do_predict""": True,
  					    """model_name_or_path""": """sshleifer/tinier_bart""",
  					    """teacher""": CHEAP_ARGS["""model_name_or_path"""],
  					    """val_check_interval""": 0.5,
  					}
  					default_updates.update(__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       CHEAP_ARGS.copy()
  					__lowerCAmelCase      		=       make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()    )
  					__lowerCAmelCase      		=       self.get_auto_remove_tmp_dir()
  					args_d.update(data_dir=__SCREAMING_SNAKE_CASE,output_dir=__SCREAMING_SNAKE_CASE,**__SCREAMING_SNAKE_CASE    )
  
  					def convert(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    ):
  								if k in ["tgt_suffix", "server_ip", "server_port", "out", "n_tpu_cores"]:
  											return ""
  								if v is False or v is None:
  											return ""
  								if v is True:  # or len(str(v))==0:
  											return f'--{k}'
  								return f'--{k}={v}'
  
  					__lowerCAmelCase      		=       [x for x in (convert(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    ) for k, v in args_d.items()) if len(__SCREAMING_SNAKE_CASE    )]
  					__lowerCAmelCase      		=       [sys.executable, f'{self.test_file_dir}/distillation.py'] + cli_args
  					execute_subprocess_async(__SCREAMING_SNAKE_CASE,env=self.get_env()    )
  
  					__lowerCAmelCase      		=       os.listdir(__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       {os.path.basename(__SCREAMING_SNAKE_CASE    ) for p in contents}
  					__lowerCAmelCase      		=       [p for p in contents if p.endswith("""ckpt"""    )]
  					assert len(__SCREAMING_SNAKE_CASE    ) > 0
  
  					self.assertIn("""test_generations.txt""",__SCREAMING_SNAKE_CASE    )
  					self.assertIn("""test_results.txt""",__SCREAMING_SNAKE_CASE    )
  
  					# get the following from the module, (we don't have access to `model` here)
  					__lowerCAmelCase      		=       os.path.join(__SCREAMING_SNAKE_CASE,"""metrics.json"""    )
  					__lowerCAmelCase      		=       """rouge2"""
  
  					__lowerCAmelCase      		=       load_json(__SCREAMING_SNAKE_CASE    )
  					# {'test': [{'test_avg_loss': 10.63731575012207, 'test_avg_rouge1': 0.0, 'test_avg_rouge2': 0.0, 'test_avg_rougeL': 0.0, 'test_avg_gen_time': 0.1822289228439331, 'test_avg_gen_len': 142.0, 'step_count': 1}]}
  					print(__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       metrics["""val"""][-1]
  					self.assertGreaterEqual(last_step_stats["""val_avg_gen_time"""],0.01    )
  					self.assertIsInstance(last_step_stats[f'val_avg_{val_metric}'],__SCREAMING_SNAKE_CASE    )
  					self.assertEqual(len(metrics["""test"""]    ),1    )
  					__lowerCAmelCase      		=       int(args_d["""max_epochs"""] * (1 / args_d["""val_check_interval"""]) / 2 + 1    )
  					self.assertEqual(len(metrics["""val"""]    ),__SCREAMING_SNAKE_CASE    )
  
  