code: 
  
  
  
  
  
  
  from __future__ import annotations
  
  import unittest
  
  from transformers import CTRLConfig, is_tf_available
  from transformers.testing_utils import require_tf, slow
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_tf_available():
     import tensorflow as tf
  
     from transformers.models.ctrl.modeling_tf_ctrl import (
         TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
         TFCTRLForSequenceClassification,
         TFCTRLLMHeadModel,
         TFCTRLModel,
     )
  
  class 					snake_case_							(       lowercase_      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     def __init__(    self:	Any   ,       snake_case__:	int   ,       )  ->		Any:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	parent
         _lowercase     =	13
         _lowercase     =	7
         _lowercase     =	True
         _lowercase     =	True
         _lowercase     =	True
         _lowercase     =	True
         _lowercase     =	True
         _lowercase     =	99
         _lowercase     =	32
         _lowercase     =	2
         _lowercase     =	4
         _lowercase     =	37
         _lowercase     =	'gelu'
         _lowercase     =	0.1
         _lowercase     =	0.1
         _lowercase     =	512
         _lowercase     =	16
         _lowercase     =	2
         _lowercase     =	0.02
         _lowercase     =	3
         _lowercase     =	4
         _lowercase     =	None
         _lowercase     =	self.vocab_size - 1
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	List[str]	)  ->		Tuple:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	ids_tensor([self.batch_size, self.seq_length]   ,       self.vocab_size	)
  
         _lowercase     =	None
         if self.use_input_mask:
             _lowercase     =	random_attention_mask([self.batch_size, self.seq_length]	)
  
         _lowercase     =	None
         if self.use_token_type_ids:
             _lowercase     =	ids_tensor([self.batch_size, self.seq_length]   ,       self.type_vocab_size	)
  
         _lowercase     =	None
         if self.use_mc_token_ids:
             _lowercase     =	ids_tensor([self.batch_size, self.num_choices]   ,       self.seq_length	)
  
         _lowercase     =	None
         _lowercase     =	None
         _lowercase     =	None
         if self.use_labels:
             _lowercase     =	ids_tensor([self.batch_size]   ,       self.type_sequence_label_size	)
             _lowercase     =	ids_tensor([self.batch_size, self.seq_length]   ,       self.num_labels	)
             _lowercase     =	ids_tensor([self.batch_size]   ,       self.num_choices	)
  
         _lowercase     =	CTRLConfig(
             vocab_size=self.vocab_size   ,       n_embd=self.hidden_size   ,       n_layer=self.num_hidden_layers   ,       n_head=self.num_attention_heads   ,       n_positions=self.max_position_embeddings   ,       pad_token_id=self.pad_token_id   ,       )
  
         _lowercase     =	ids_tensor([self.num_hidden_layers, self.num_attention_heads]   ,       2	)
  
         return (
             config,
             input_ids,
             input_mask,
             head_mask,
             token_type_ids,
             mc_token_ids,
             sequence_labels,
             token_labels,
             choice_labels,
         )
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[int]   ,       snake_case__:	List[Any]   ,       snake_case__:	Optional[Any]   ,       snake_case__:	List[str]   ,       snake_case__:	str   ,       snake_case__:	Optional[Any]   ,       *snake_case__:	int	)  ->		List[Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	TFCTRLModel(config=snake_case__	)
         _lowercase     =	{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
         _lowercase     =	model(snake_case__	)
  
         _lowercase     =	[input_ids, None, input_mask]  # None is the input for 'past'
         _lowercase     =	model(snake_case__	)
  
         _lowercase     =	model(snake_case__	)
  
         self.parent.assertEqual(result.last_hidden_state.shape   ,       (self.batch_size, self.seq_length, self.hidden_size)	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Any   ,       snake_case__:	Optional[int]   ,       snake_case__:	int   ,       snake_case__:	Tuple   ,       snake_case__:	Optional[Any]   ,       snake_case__:	List[Any]   ,       *snake_case__:	str	)  ->		Union[str, Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	TFCTRLLMHeadModel(config=snake_case__	)
         _lowercase     =	{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
         _lowercase     =	model(snake_case__	)
         self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.seq_length, self.vocab_size)	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]   ,       snake_case__:	Dict   ,       snake_case__:	List[Any]   ,       snake_case__:	int   ,       snake_case__:	Tuple   ,       snake_case__:	Dict   ,       *snake_case__:	Optional[Any]	)  ->		Optional[int]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.num_labels
         _lowercase     =	ids_tensor([self.batch_size]   ,       self.type_sequence_label_size	)
         _lowercase     =	{
             'input_ids': input_ids,
             'token_type_ids': token_type_ids,
             'labels': sequence_labels,
         }
         _lowercase     =	TFCTRLForSequenceClassification(snake_case__	)
         _lowercase     =	model(snake_case__	)
         self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.num_labels)	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Any	)  ->		Optional[Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.prepare_config_and_inputs()
  
         (
             (
             _lowercase
         ) ,    (
             _lowercase
         ) ,    (
             _lowercase
         ) ,    (
             _lowercase
         ) ,    (
             _lowercase
         ) ,    (
             _lowercase
         ) ,    (
             _lowercase
         ) ,    (
             _lowercase
         ) ,    (
             _lowercase
         ) ,    
         )     =	config_and_inputs
  
         _lowercase     =	{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
         return config, inputs_dict
  
  
  
  
  
  
  @require_tf
  class 					snake_case_							(       lowercase_      ,			lowercase_      ,			unittest.TestCase      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     __lowerCAmelCase      =						(TFCTRLModel, TFCTRLLMHeadModel, TFCTRLForSequenceClassification) if is_tf_available() else ()
     __lowerCAmelCase      =						(TFCTRLLMHeadModel,) if is_tf_available() else ()
     __lowerCAmelCase      =						(
         {
             """feature-extraction""": TFCTRLModel,
             """text-classification""": TFCTRLForSequenceClassification,
             """text-generation""": TFCTRLLMHeadModel,
             """zero-shot""": TFCTRLForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )
     __lowerCAmelCase      =						False
     __lowerCAmelCase      =						False
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	List[str]   ,       snake_case__:	Dict   ,       snake_case__:	int   ,       snake_case__:	Optional[int]   ,       snake_case__:	Optional[int]   ,       snake_case__:	List[Any]	)  ->		Any:
  
  
         """simple docstring"""
  
  
  
         if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
             # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
             # `CTRLConfig` was never used in pipeline tests, either because of a missing checkpoint or because a tiny
             # config could not be created.
             return True
  
         return False
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Tuple	)  ->		Dict:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	TFCTRLModelTester(self	)
         _lowercase     =	ConfigTester(self   ,       config_class=snake_case__   ,       n_embd=37	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Any	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         self.config_tester.run_common_tests()
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Union[str, Any]	)  ->		str:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_ctrl_model(*snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Any	)  ->		List[str]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_ctrl_lm_head(*snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	str	)  ->		List[str]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_ctrl_for_sequence_classification(*snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Dict	)  ->		Optional[int]:
  
  
         """simple docstring"""
  
  
  
         _lowercase ,    _lowercase     =	self.model_tester.prepare_config_and_inputs_for_common()
         _lowercase     =	[TFCTRLLMHeadModel]
         _lowercase     =	[TFCTRLForSequenceClassification]
  
         for model_class in self.all_model_classes:
             _lowercase     =	model_class(snake_case__	)
             model.build()  # may be needed for the get_bias() call below
             assert isinstance(model.get_input_embeddings()   ,       tf.keras.layers.Layer	)
  
             if model_class in list_lm_models:
                 _lowercase     =	model.get_output_embeddings()
                 assert isinstance(snake_case__   ,       tf.keras.layers.Layer	)
                 _lowercase     =	model.get_bias()
                 assert isinstance(snake_case__   ,       snake_case__	)
                 for k, v in name.items():
                     assert isinstance(snake_case__   ,       tf.Variable	)
             elif model_class in list_other_models_with_output_ebd:
                 _lowercase     =	model.get_output_embeddings()
                 assert isinstance(snake_case__   ,       tf.keras.layers.Layer	)
                 _lowercase     =	model.get_bias()
                 assert name is None
             else:
                 _lowercase     =	model.get_output_embeddings()
                 assert x is None
                 _lowercase     =	model.get_bias()
                 assert name is None
  
     @slow
     def 			SCREAMING_SNAKE_CASE__				(    self:	List[Any]	)  ->		Tuple:
  
  
         """simple docstring"""
  
  
  
         for model_name in TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _lowercase     =	TFCTRLModel.from_pretrained(snake_case__	)
             self.assertIsNotNone(snake_case__	)
  
  
  
  
  
  
  @require_tf
  class 					snake_case_							(       unittest.TestCase      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     @slow
     def 			SCREAMING_SNAKE_CASE__				(    self:	List[Any]	)  ->		List[str]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	TFCTRLLMHeadModel.from_pretrained('ctrl'	)
         _lowercase     =	tf.convert_to_tensor([[11_859, 0, 1_611, 8]]   ,       dtype=tf.intaa	)  # Legal the president is
         _lowercase     =	[
             11_859,
             0,
             1_611,
             8,
             5,
             150,
             26_449,
             2,
             19,
             348,
             469,
             3,
             2_595,
             48,
             20_740,
             246_533,
             246_533,
             19,
             30,
             5,
         ]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a
  
         _lowercase     =	model.generate(snake_case__   ,       do_sample=snake_case__	)
         self.assertListEqual(output_ids[0].numpy().tolist()   ,       snake_case__	)
  
style_context: 
  
  
  
  
  
  
  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
  
  
  lowerCamelCase										=  get_tests_dir('''fixtures/test_sentencepiece_bpe_char.model''')
  
  @require_torch
  class 					snake_case_							(       unittest.TestCase      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	List[str]	)  ->		Union[str, Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	tempfile.mkdtemp()
  
         _lowercase     =	SpeechTaTokenizer(snake_case__	)
         tokenizer.save_pretrained(self.tmpdirname	)
  
         _lowercase     =	{
             'feature_size': 1,
             'padding_value': 0.0,
             'sampling_rate': 16_000,
             'do_normalize': False,
             'num_mel_bins': 80,
             'hop_length': 16,
             'win_length': 64,
             'win_function': 'hann_window',
             'fmin': 80,
             'fmax': 7_600,
             'mel_floor': 1E-10,
             'reduction_factor': 2,
             'return_attention_mask': True,
         }
  
         _lowercase     =	os.path.join(self.tmpdirname   ,       snake_case__	)
         with open(self.feature_extraction_file   ,       'w'   ,       encoding='utf-8'	) as fp:
             fp.write(json.dumps(snake_case__	) + '\n'	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Union[str, Any]   ,       **snake_case__:	Union[str, Any]	)  ->		Union[str, Any]:
  
  
         """simple docstring"""
  
  
  
         return SpeechTaTokenizer.from_pretrained(self.tmpdirname   ,       **snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[int]   ,       **snake_case__:	str	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname   ,       **snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]	)  ->		Optional[int]:
  
  
         """simple docstring"""
  
  
  
         shutil.rmtree(self.tmpdirname	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	int	)  ->		List[str]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_tokenizer()
         _lowercase     =	self.get_feature_extractor()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         processor.save_pretrained(self.tmpdirname	)
         _lowercase     =	SpeechTaProcessor.from_pretrained(self.tmpdirname	)
  
         self.assertEqual(processor.tokenizer.get_vocab()   ,       tokenizer.get_vocab()	)
         self.assertIsInstance(processor.tokenizer   ,       snake_case__	)
  
         self.assertEqual(processor.feature_extractor.to_json_string()   ,       feature_extractor.to_json_string()	)
         self.assertIsInstance(processor.feature_extractor   ,       snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	int	)  ->		Any:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	SpeechTaProcessor(tokenizer=self.get_tokenizer()   ,       feature_extractor=self.get_feature_extractor()	)
         processor.save_pretrained(self.tmpdirname	)
  
         _lowercase     =	self.get_tokenizer(bos_token='(BOS)'   ,       eos_token='(EOS)'	)
         _lowercase     =	self.get_feature_extractor(do_normalize=snake_case__   ,       padding_value=1.0	)
  
         _lowercase     =	SpeechTaProcessor.from_pretrained(
             self.tmpdirname   ,       bos_token='(BOS)'   ,       eos_token='(EOS)'   ,       do_normalize=snake_case__   ,       padding_value=1.0	)
  
         self.assertEqual(processor.tokenizer.get_vocab()   ,       tokenizer_add_kwargs.get_vocab()	)
         self.assertIsInstance(processor.tokenizer   ,       snake_case__	)
  
         self.assertEqual(processor.feature_extractor.to_json_string()   ,       feature_extractor_add_kwargs.to_json_string()	)
         self.assertIsInstance(processor.feature_extractor   ,       snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Union[str, Any]	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_feature_extractor()
         _lowercase     =	self.get_tokenizer()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         _lowercase     =	floats_list((3, 1_000)	)
  
         _lowercase     =	feature_extractor(audio=snake_case__   ,       return_tensors='np'	)
         _lowercase     =	processor(audio=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 			SCREAMING_SNAKE_CASE__				(    self:	Tuple	)  ->		List[str]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_feature_extractor()
         _lowercase     =	self.get_tokenizer()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         _lowercase     =	floats_list((3, 1_000)	)
  
         _lowercase     =	feature_extractor(audio_target=snake_case__   ,       return_tensors='np'	)
         _lowercase     =	processor(audio_target=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 			SCREAMING_SNAKE_CASE__				(    self:	Dict	)  ->		Dict:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_feature_extractor()
         _lowercase     =	self.get_tokenizer()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         _lowercase     =	'This is a test string'
  
         _lowercase     =	processor(text=snake_case__	)
         _lowercase     =	tokenizer(snake_case__	)
  
         for key in encoded_tok.keys():
             self.assertListEqual(encoded_tok[key]   ,       encoded_processor[key]	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[int]	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_feature_extractor()
         _lowercase     =	self.get_tokenizer()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         _lowercase     =	'This is a test string'
  
         _lowercase     =	processor(text_target=snake_case__	)
         _lowercase     =	tokenizer(snake_case__	)
  
         for key in encoded_tok.keys():
             self.assertListEqual(encoded_tok[key]   ,       encoded_processor[key]	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Dict	)  ->		int:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_feature_extractor()
         _lowercase     =	self.get_tokenizer()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         _lowercase     =	[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]
  
         _lowercase     =	processor.batch_decode(snake_case__	)
         _lowercase     =	tokenizer.batch_decode(snake_case__	)
  
         self.assertListEqual(snake_case__   ,       snake_case__	)
  
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]	)  ->		List[Any]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	self.get_feature_extractor()
         _lowercase     =	self.get_tokenizer()
  
         _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)
  
         self.assertListEqual(
             processor.model_input_names   ,       feature_extractor.model_input_names   ,       msg='`processor` and `feature_extractor` model input names do not match'   ,       )
  