



import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin




class 					snake_case__						(       lowerCAmelCase_     ):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE						=	None
     _SCREAMING_SNAKE_CASE						=	None






     @property
     def    lowercase_   (       self  :  Optional[int]					)   ->Union[str, Any]:
            return self.feat_extract_tester.prepare_feat_extract_dict()






     def    lowercase_   (       self  :  Dict					)   ->int:
            snake_case__							:	List[Any]   	=	self.feature_extraction_class(**self.feat_extract_dict					)
            self.assertTrue(hasattr(_snake_case, 'feature_size'					)					)
            self.assertTrue(hasattr(_snake_case, 'sampling_rate'					)					)
            self.assertTrue(hasattr(_snake_case, 'padding_value'					)					)






     def    lowercase_   (       self  :  Union[str, Any]					)   ->Optional[Any]:
            snake_case__							:	Optional[int]   	=	self.feat_extract_tester.prepare_inputs_for_common()
            snake_case__							:	List[Any]   	=	self.feature_extraction_class(**self.feat_extract_dict					)
            snake_case__							:	List[str]   	=	feat_extract.model_input_names[0]

            snake_case__							:	int   	=	BatchFeature({input_name: speech_inputs}					)

            self.assertTrue(all(len(_snake_case					) == len(_snake_case					) for x, y in zip(_snake_case, processed_features[input_name]					)					)					)

            snake_case__							:	str   	=	self.feat_extract_tester.prepare_inputs_for_common(equal_length=_snake_case					)
            snake_case__							:	List[Any]   	=	BatchFeature({input_name: speech_inputs}, tensor_type='np'					)

            snake_case__							:	str   	=	processed_features[input_name]

            if len(batch_features_input.shape					) < 3:
                   snake_case__							:	Optional[Any]   	=	batch_features_input[:, :, None]

            self.assertTrue(
                batch_features_input.shape
                == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.feature_size)					)






     @require_torch
     def    lowercase_   (       self  :  Optional[Any]					)   ->int:
            snake_case__							:	Dict   	=	self.feat_extract_tester.prepare_inputs_for_common(equal_length=_snake_case					)
            snake_case__							:	List[Any]   	=	self.feature_extraction_class(**self.feat_extract_dict					)
            snake_case__							:	Optional[int]   	=	feat_extract.model_input_names[0]

            snake_case__							:	Dict   	=	BatchFeature({input_name: speech_inputs}, tensor_type='pt'					)

            snake_case__							:	Union[str, Any]   	=	processed_features[input_name]

            if len(batch_features_input.shape					) < 3:
                   snake_case__							:	Optional[int]   	=	batch_features_input[:, :, None]

            self.assertTrue(
                batch_features_input.shape
                == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.feature_size)					)






     @require_tf
     def    lowercase_   (       self  :  int					)   ->Any:
            snake_case__							:	List[Any]   	=	self.feat_extract_tester.prepare_inputs_for_common(equal_length=_snake_case					)
            snake_case__							:	str   	=	self.feature_extraction_class(**self.feat_extract_dict					)
            snake_case__							:	Union[str, Any]   	=	feat_extract.model_input_names[0]

            snake_case__							:	int   	=	BatchFeature({input_name: speech_inputs}, tensor_type='tf'					)

            snake_case__							:	List[str]   	=	processed_features[input_name]

            if len(batch_features_input.shape					) < 3:
                   snake_case__							:	List[Any]   	=	batch_features_input[:, :, None]

            self.assertTrue(
                batch_features_input.shape
                == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.feature_size)					)






     def    lowercase_   (       self  :  Tuple, _snake_case  :  int=False					)   ->Union[str, Any]:
            def _inputs_have_equal_length(_snake_case  :  Union[str, Any]					):
                   snake_case__							:	str   	=	len(input[0]					)
                   for input_slice in input[1:]:
                          if len(_snake_case					) != length:
                                 return False
                   return True

            def _inputs_are_equal(_snake_case  :  List[Any], _snake_case  :  Optional[Any]					):
                   if len(_snake_case					) != len(_snake_case					):
                          return False

                   for input_slice_a, input_slice_a in zip(_snake_case, _snake_case					):
                          if not np.allclose(np.asarray(_snake_case					), np.asarray(_snake_case					), atol=1e-3					):
                                 return False
                   return True

            snake_case__							:	int   	=	self.feature_extraction_class(**self.feat_extract_dict					)
            snake_case__							:	Any   	=	self.feat_extract_tester.prepare_inputs_for_common(numpify=_snake_case					)
            snake_case__							:	Tuple   	=	feat_extract.model_input_names[0]

            snake_case__							:	Union[str, Any]   	=	BatchFeature({input_name: speech_inputs}					)

            snake_case__							:	Optional[int]   	=	self.feat_extract_tester.seq_length_diff
            snake_case__							:	Union[str, Any]   	=	self.feat_extract_tester.max_seq_length + pad_diff
            snake_case__							:	List[Any]   	=	self.feat_extract_tester.min_seq_length
            snake_case__							:	int   	=	self.feat_extract_tester.batch_size
            snake_case__							:	Union[str, Any]   	=	self.feat_extract_tester.feature_size

            # test padding for List[int] + numpy
            snake_case__							:	Dict   	=	feat_extract.pad(_snake_case, padding=_snake_case					)
            snake_case__							:	List[Any]   	=	input_a[input_name]

            snake_case__							:	Union[str, Any]   	=	feat_extract.pad(_snake_case, padding='longest'					)
            snake_case__							:	int   	=	input_a[input_name]

            snake_case__							:	Dict   	=	feat_extract.pad(_snake_case, padding='max_length', max_length=len(speech_inputs[-1]					)					)
            snake_case__							:	List[Any]   	=	input_a[input_name]

            snake_case__							:	List[Any]   	=	feat_extract.pad(_snake_case, padding='longest', return_tensors='np'					)
            snake_case__							:	int   	=	input_a[input_name]

            # max_length parameter has to be provided when setting `padding="max_length"`
            with self.assertRaises(_snake_case					):
                   feat_extract.pad(_snake_case, padding='max_length'					)[input_name]

            snake_case__							:	int   	=	feat_extract.pad(
                _snake_case, padding='max_length', max_length=_snake_case, return_tensors='np'					)
            snake_case__							:	int   	=	input_a[input_name]

            self.assertFalse(_inputs_have_equal_length(_snake_case					)					)
            self.assertTrue(_inputs_have_equal_length(_snake_case					)					)
            self.assertTrue(_inputs_have_equal_length(_snake_case					)					)
            self.assertTrue(_inputs_are_equal(_snake_case, _snake_case					)					)
            self.assertTrue(len(input_a[0]					) == pad_min_length					)
            self.assertTrue(len(input_a[1]					) == pad_min_length + pad_diff					)
            self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]					))					)
            self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)					)

            if feature_size > 1:
                   self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size					)

            # test padding for `pad_to_multiple_of` for List[int] + numpy
            snake_case__							:	str   	=	feat_extract.pad(_snake_case, pad_to_multiple_of=1_0					)
            snake_case__							:	Any   	=	input_a[input_name]

            snake_case__							:	Dict   	=	feat_extract.pad(_snake_case, padding='longest', pad_to_multiple_of=1_0					)
            snake_case__							:	Any   	=	input_a[input_name]

            snake_case__							:	Tuple   	=	feat_extract.pad(
                _snake_case, padding='max_length', pad_to_multiple_of=1_0, max_length=_snake_case					)
            snake_case__							:	List[Any]   	=	input_a[input_name]

            snake_case__							:	Dict   	=	feat_extract.pad(
                _snake_case, padding='max_length', pad_to_multiple_of=1_0, max_length=_snake_case, return_tensors='np', )
            snake_case__							:	List[str]   	=	input_a[input_name]

            self.assertTrue(all(len(_snake_case					) % 1_0 == 0 for x in input_a					)					)
            self.assertTrue(_inputs_are_equal(_snake_case, _snake_case					)					)

            snake_case__							:	Any   	=	pad_max_length if pad_max_length % 1_0 == 0 else (pad_max_length // 1_0 + 1) * 1_0
            self.assertTrue(all(len(_snake_case					) == expected_mult_pad_length for x in input_a					)					)
            self.assertEqual(input_a.shape[:2], (batch_size, expected_mult_pad_length)					)

            if feature_size > 1:
                   self.assertTrue(input_a.shape[2] == feature_size					)

            # Check padding value is correct
            snake_case__							:	Dict   	=	(np.ones(self.feat_extract_tester.feature_size					) * feat_extract.padding_value).sum()
            self.assertTrue(
                abs(np.asarray(input_a[0]					)[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)					)
                < 1e-3					)
            self.assertTrue(
                abs(
                    np.asarray(input_a[1]					)[pad_min_length + pad_diff :].sum()
                    - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)					)
                < 1e-3					)
            self.assertTrue(
                abs(
                    np.asarray(input_a[2]					)[pad_min_length + 2 * pad_diff :].sum()
                    - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)					)
                < 1e-3					)
            self.assertTrue(
                abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)					) < 1e-3					)
            self.assertTrue(
                abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)					)
                < 1e-3					)






     def    lowercase_   (       self  :  Optional[Any], _snake_case  :  str=False					)   ->Optional[int]:
            def _inputs_have_equal_length(_snake_case  :  Dict					):
                   snake_case__							:	Union[str, Any]   	=	len(input[0]					)
                   for input_slice in input[1:]:
                          if len(_snake_case					) != length:
                                 return False
                   return True

            def _inputs_are_equal(_snake_case  :  List[Any], _snake_case  :  Optional[Any]					):
                   if len(_snake_case					) != len(_snake_case					):
                          return False

                   for input_slice_a, input_slice_a in zip(_snake_case, _snake_case					):
                          if not np.allclose(np.asarray(_snake_case					), np.asarray(_snake_case					), atol=1e-3					):
                                 return False
                   return True

            snake_case__							:	Dict   	=	self.feature_extraction_class(**self.feat_extract_dict					)
            snake_case__							:	List[str]   	=	self.feat_extract_tester.prepare_inputs_for_common(numpify=_snake_case					)
            snake_case__							:	str   	=	feat_extract.model_input_names[0]

            snake_case__							:	Tuple   	=	BatchFeature({input_name: speech_inputs}					)

            # truncate to smallest
            snake_case__							:	Tuple   	=	feat_extract.pad(
                _snake_case, padding='max_length', max_length=len(speech_inputs[0]					), truncation=_snake_case					)
            snake_case__							:	Union[str, Any]   	=	input_a[input_name]

            snake_case__							:	Dict   	=	feat_extract.pad(_snake_case, padding='max_length', max_length=len(speech_inputs[0]					)					)
            snake_case__							:	Optional[Any]   	=	input_a[input_name]

            self.assertTrue(_inputs_have_equal_length(_snake_case					)					)
            self.assertFalse(_inputs_have_equal_length(_snake_case					)					)

            # truncate to smallest with np
            snake_case__							:	List[Any]   	=	feat_extract.pad(
                _snake_case, padding='max_length', max_length=len(speech_inputs[0]					), return_tensors='np', truncation=_snake_case, )
            snake_case__							:	Any   	=	input_a[input_name]

            snake_case__							:	Union[str, Any]   	=	feat_extract.pad(
                _snake_case, padding='max_length', max_length=len(speech_inputs[0]					), return_tensors='np'					)
            snake_case__							:	Any   	=	input_a[input_name]

            self.assertTrue(_inputs_have_equal_length(_snake_case					)					)
            self.assertTrue(input_a.shape[1] == len(speech_inputs[0]					)					)

            # since truncation forces padding to be smaller than longest input
            # function can't return `np.ndarray`, but has to return list
            self.assertFalse(_inputs_have_equal_length(_snake_case					)					)

            # truncate to middle
            snake_case__							:	Union[str, Any]   	=	feat_extract.pad(
                _snake_case, padding='max_length', max_length=len(speech_inputs[1]					), truncation=_snake_case, return_tensors='np', )
            snake_case__							:	Optional[int]   	=	input_a[input_name]

            snake_case__							:	Union[str, Any]   	=	feat_extract.pad(
                _snake_case, padding='max_length', max_length=len(speech_inputs[1]					), truncation=_snake_case					)
            snake_case__							:	Optional[Any]   	=	input_a[input_name]

            snake_case__							:	Tuple   	=	feat_extract.pad(
                _snake_case, padding='max_length', max_length=len(speech_inputs[1]					), return_tensors='np'					)
            snake_case__							:	str   	=	input_a[input_name]

            self.assertTrue(input_a.shape[1] == len(speech_inputs[1]					)					)
            self.assertTrue(_inputs_have_equal_length(_snake_case					)					)
            self.assertTrue(_inputs_have_equal_length(_snake_case					)					)
            self.assertTrue(_inputs_are_equal(_snake_case, _snake_case					)					)

            # since truncation forces padding to be smaller than longest input
            # function can't return `np.ndarray`, but has to return list
            self.assertFalse(_inputs_have_equal_length(_snake_case					)					)
            self.assertTrue(len(input_a[-1]					) == len(speech_inputs[-1]					)					)

            # padding has to be max_length when setting `truncation=True`
            with self.assertRaises(_snake_case					):
                   feat_extract.pad(_snake_case, truncation=_snake_case					)[input_name]

            # padding has to be max_length when setting `truncation=True`
            with self.assertRaises(_snake_case					):
                   feat_extract.pad(_snake_case, padding='longest', truncation=_snake_case					)[input_name]

            # padding has to be max_length when setting `truncation=True`
            with self.assertRaises(_snake_case					):
                   feat_extract.pad(_snake_case, padding='longest', truncation=_snake_case					)[input_name]

            # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
            with self.assertRaises(_snake_case					):
                   feat_extract.pad(_snake_case, padding='max_length', truncation=_snake_case					)[input_name]

            # test truncation for `pad_to_multiple_of` for List[int] + numpy
            snake_case__							:	List[str]   	=	1_2
            snake_case__							:	Optional[int]   	=	feat_extract.pad(
                _snake_case, padding='max_length', max_length=len(speech_inputs[0]					), pad_to_multiple_of=_snake_case, truncation=_snake_case, )
            snake_case__							:	Tuple   	=	input_a[input_name]

            snake_case__							:	Tuple   	=	feat_extract.pad(
                _snake_case, padding='max_length', max_length=len(speech_inputs[0]					), pad_to_multiple_of=_snake_case, )
            snake_case__							:	Dict   	=	input_a[input_name]

            # retrieve expected_length as multiple of pad_to_multiple_of
            snake_case__							:	str   	=	len(speech_inputs[0]					)
            if expected_length % pad_to_multiple_of != 0:
                   snake_case__							:	List[str]   	=	((len(speech_inputs[0]					) // pad_to_multiple_of) + 1) * pad_to_multiple_of

            self.assertTrue(len(input_a[0]					) == expected_length					)
            self.assertTrue(_inputs_have_equal_length(_snake_case					)					)
            self.assertFalse(_inputs_have_equal_length(_snake_case					)					)






     def    lowercase_   (       self  :  List[Any]					)   ->str:
            self._check_padding(numpify=_snake_case					)






     def    lowercase_   (       self  :  Optional[Any]					)   ->Union[str, Any]:
            self._check_padding(numpify=_snake_case					)






     def    lowercase_   (       self  :  Optional[Any]					)   ->Union[str, Any]:
            self._check_truncation(numpify=_snake_case					)






     def    lowercase_   (       self  :  Optional[Any]					)   ->Union[str, Any]:
            self._check_truncation(numpify=_snake_case					)






     @require_torch
     def    lowercase_   (       self  :  Union[str, Any]					)   ->Union[str, Any]:
            snake_case__							:	List[Any]   	=	self.feature_extraction_class(**self.feat_extract_dict					)
            snake_case__							:	Dict   	=	self.feat_extract_tester.prepare_inputs_for_common()
            snake_case__							:	Any   	=	feat_extract.model_input_names[0]

            snake_case__							:	Any   	=	BatchFeature({input_name: speech_inputs}					)

            snake_case__							:	Optional[int]   	=	feat_extract.pad(_snake_case, padding='longest', return_tensors='np'					)[input_name]
            snake_case__							:	List[Any]   	=	feat_extract.pad(_snake_case, padding='longest', return_tensors='pt'					)[input_name]

            self.assertTrue(abs(input_np.astype(np.floataa					).sum() - input_pt.numpy().astype(np.floataa					).sum()					) < 1e-2					)






     @require_tf
     def    lowercase_   (       self  :  Dict					)   ->Dict:
            snake_case__							:	Dict   	=	self.feature_extraction_class(**self.feat_extract_dict					)
            snake_case__							:	List[str]   	=	self.feat_extract_tester.prepare_inputs_for_common()
            snake_case__							:	Union[str, Any]   	=	feat_extract.model_input_names[0]

            snake_case__							:	List[Any]   	=	BatchFeature({input_name: speech_inputs}					)

            snake_case__							:	List[str]   	=	feat_extract.pad(_snake_case, padding='longest', return_tensors='np'					)[input_name]
            snake_case__							:	Any   	=	feat_extract.pad(_snake_case, padding='longest', return_tensors='tf'					)[input_name]

            self.assertTrue(abs(input_np.astype(np.floataa					).sum() - input_tf.numpy().astype(np.floataa					).sum()					) < 1e-2					)






     def    lowercase_   (       self  :  Optional[int]					)   ->List[str]:
            snake_case__							:	List[Any]   	=	self.feat_extract_dict
            snake_case__							:	List[Any]   	=	True
            snake_case__							:	Union[str, Any]   	=	self.feature_extraction_class(**_snake_case					)
            snake_case__							:	str   	=	self.feat_extract_tester.prepare_inputs_for_common()
            snake_case__							:	List[str]   	=	[len(_snake_case					) for x in speech_inputs]
            snake_case__							:	List[Any]   	=	feat_extract.model_input_names[0]

            snake_case__							:	Optional[Any]   	=	BatchFeature({input_name: speech_inputs}					)

            snake_case__							:	Optional[Any]   	=	feat_extract.pad(_snake_case, padding='longest', return_tensors='np'					)
            self.assertIn('attention_mask', _snake_case					)
            self.assertListEqual(list(processed.attention_mask.shape					), list(processed[input_name].shape[:2]					)					)
            self.assertListEqual(processed.attention_mask.sum(-1					).tolist(), _snake_case					)






     def    lowercase_   (       self  :  Optional[Any]					)   ->Tuple:
            snake_case__							:	Optional[Any]   	=	self.feat_extract_dict
            snake_case__							:	Any   	=	True
            snake_case__							:	Optional[Any]   	=	self.feature_extraction_class(**_snake_case					)
            snake_case__							:	Optional[int]   	=	self.feat_extract_tester.prepare_inputs_for_common()
            snake_case__							:	Optional[int]   	=	[len(_snake_case					) for x in speech_inputs]
            snake_case__							:	int   	=	feat_extract.model_input_names[0]

            snake_case__							:	str   	=	BatchFeature({input_name: speech_inputs}					)
            snake_case__							:	Optional[int]   	=	min(_snake_case					)

            snake_case__							:	List[str]   	=	feat_extract.pad(
                _snake_case, padding='max_length', max_length=_snake_case, truncation=_snake_case, return_tensors='np'					)
            self.assertIn('attention_mask', _snake_case					)
            self.assertListEqual(
                list(processed_pad.attention_mask.shape					), [processed_pad[input_name].shape[0], max_length]					)
            self.assertListEqual(
                processed_pad.attention_mask[:, :max_length].sum(-1					).tolist(), [max_length for x in speech_inputs]					)











from ...configuration_utils import PretrainedConfig
from ...utils import logging


a_   :Optional[int]        =      logging.get_logger(__name__)

a_   :Dict        =      {"openai-gpt": "https://huggingface.co/openai-gpt/resolve/main/config.json"}




class 					snake_case__						(       lowerCAmelCase_     ):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE						=	"""openai-gpt"""
     _SCREAMING_SNAKE_CASE						=	{
         """max_position_embeddings""": """n_positions""",
         """hidden_size""": """n_embd""",
         """num_attention_heads""": """n_head""",
         """num_hidden_layers""": """n_layer""",
     }






     def __init__(       self  :  Optional[int], _snake_case  :  Dict=4_0_4_7_8, _snake_case  :  str=5_1_2, _snake_case  :  int=7_6_8, _snake_case  :  Tuple=1_2, _snake_case  :  Any=1_2, _snake_case  :  str="gelu", _snake_case  :  List[str]=0.1, _snake_case  :  Any=0.1, _snake_case  :  Dict=0.1, _snake_case  :  int=1e-5, _snake_case  :  Optional[Any]=0.0_2, _snake_case  :  List[Any]="cls_index", _snake_case  :  Any=True, _snake_case  :  Any=None, _snake_case  :  int=True, _snake_case  :  Optional[Any]=0.1, **_snake_case  :  List[Any], )   ->Optional[int]:
            snake_case__							:	int   	=	vocab_size
            snake_case__							:	Dict   	=	n_positions
            snake_case__							:	str   	=	n_embd
            snake_case__							:	str   	=	n_layer
            snake_case__							:	List[Any]   	=	n_head
            snake_case__							:	List[Any]   	=	afn
            snake_case__							:	Optional[Any]   	=	resid_pdrop
            snake_case__							:	List[str]   	=	embd_pdrop
            snake_case__							:	List[Any]   	=	attn_pdrop
            snake_case__							:	Optional[int]   	=	layer_norm_epsilon
            snake_case__							:	str   	=	initializer_range
            snake_case__							:	List[str]   	=	summary_type
            snake_case__							:	Optional[int]   	=	summary_use_proj
            snake_case__							:	List[str]   	=	summary_activation
            snake_case__							:	Optional[Any]   	=	summary_first_dropout
            snake_case__							:	int   	=	summary_proj_to_labels
            super().__init__(**_snake_case					)






