

"""simple docstring"""




import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
						from transformers import SpeechaTextFeatureExtractor

lowerCAmelCase__							=				random.Random()



def        _lowerCamelCase ( __a,							__a=1.0,							__a=None,							__a=None    ):
		if rng is None:
				SCREAMING_SNAKE_CASE_						 = global_rng

		SCREAMING_SNAKE_CASE_						 = []
		for batch_idx in range(shape[0]    ):
				values.append([]    )
				for _ in range(shape[1]    ):
						values[-1].append(rng.random() * scale    )

		return values





@require_torch
@require_torchaudio
class  snake_case     (							unittest.TestCase   ):

							def __init__(self       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_=7       ,       SCREAMING_SNAKE_CASE_=4_00       ,       SCREAMING_SNAKE_CASE_=20_00       ,       SCREAMING_SNAKE_CASE_=24       ,       SCREAMING_SNAKE_CASE_=24       ,       SCREAMING_SNAKE_CASE_=0.0       ,       SCREAMING_SNAKE_CASE_=1_60_00       ,       SCREAMING_SNAKE_CASE_=True       ,       SCREAMING_SNAKE_CASE_=True       ,       ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = parent
									SCREAMING_SNAKE_CASE_						 = batch_size
									SCREAMING_SNAKE_CASE_						 = min_seq_length
									SCREAMING_SNAKE_CASE_						 = max_seq_length
									SCREAMING_SNAKE_CASE_						 = (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
									SCREAMING_SNAKE_CASE_						 = feature_size
									SCREAMING_SNAKE_CASE_						 = num_mel_bins
									SCREAMING_SNAKE_CASE_						 = padding_value
									SCREAMING_SNAKE_CASE_						 = sampling_rate
									SCREAMING_SNAKE_CASE_						 = return_attention_mask
									SCREAMING_SNAKE_CASE_						 = do_normalize

							def _lowercase					(self    ):

									"""simple docstring"""







									return {
									    "feature_size": self.feature_size,
									    "num_mel_bins": self.num_mel_bins,
									    "padding_value": self.padding_value,
									    "sampling_rate": self.sampling_rate,
									    "return_attention_mask": self.return_attention_mask,
									    "do_normalize": self.do_normalize,
									}







							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_=False       ,       SCREAMING_SNAKE_CASE_=False    ):

									"""simple docstring"""







									def _flatten(SCREAMING_SNAKE_CASE_    ):
											return list(itertools.chain(*SCREAMING_SNAKE_CASE_    )    )

									if equal_length:
											SCREAMING_SNAKE_CASE_						 = [floats_list((self.max_seq_length, self.feature_size)    ) for _ in range(self.batch_size    )]
									else:
											# make sure that inputs increase in size
											SCREAMING_SNAKE_CASE_						 = [
											    floats_list((x, self.feature_size)    )
											    for x in range(self.min_seq_length       ,       self.max_seq_length       ,       self.seq_length_diff    )
											]
									if numpify:
											SCREAMING_SNAKE_CASE_						 = [np.asarray(SCREAMING_SNAKE_CASE_    ) for x in speech_inputs]
									return speech_inputs







@require_torch
@require_torchaudio
class  snake_case     (							__lowercase       ,			unittest.TestCase   ):
							UpperCAmelCase__						     =      SpeechaTextFeatureExtractor if is_speech_available() else None

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = SpeechaTextFeatureExtractionTester(self    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									self.assertTrue(np.all(np.mean(SCREAMING_SNAKE_CASE_       ,       axis=0    ) < 1e-3    )    )
									self.assertTrue(np.all(np.abs(np.var(SCREAMING_SNAKE_CASE_       ,       axis=0    ) - 1    ) < 1e-3    )    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									# create three inputs of length 800, 1000, and 1200
									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in range(8_00       ,       14_00       ,       2_00    )]
									SCREAMING_SNAKE_CASE_						 = [np.asarray(SCREAMING_SNAKE_CASE_    ) for speech_input in speech_inputs]

									# Test feature size
									SCREAMING_SNAKE_CASE_						 = feature_extractor(SCREAMING_SNAKE_CASE_       ,       padding=SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''    ).input_features
									self.assertTrue(input_features.ndim == 3    )
									self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size    )

									# Test not batched input
									SCREAMING_SNAKE_CASE_						 = feature_extractor(speech_inputs[0]       ,       return_tensors='''np'''    ).input_features
									SCREAMING_SNAKE_CASE_						 = feature_extractor(np_speech_inputs[0]       ,       return_tensors='''np'''    ).input_features
									self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       atol=1e-3    )    )

									# Test batched
									SCREAMING_SNAKE_CASE_						 = feature_extractor(SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''    ).input_features
									SCREAMING_SNAKE_CASE_						 = feature_extractor(SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''    ).input_features
									for enc_seq_a, enc_seq_a in zip(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):
											self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       atol=1e-3    )    )

									# Test 2-D numpy arrays are batched.
									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in (8_00, 8_00, 8_00)]
									SCREAMING_SNAKE_CASE_						 = np.asarray(SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = feature_extractor(SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''    ).input_features
									SCREAMING_SNAKE_CASE_						 = feature_extractor(SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''    ).input_features
									for enc_seq_a, enc_seq_a in zip(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):
											self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       atol=1e-3    )    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in range(8_00       ,       14_00       ,       2_00    )]

									SCREAMING_SNAKE_CASE_						 = ['''longest''', '''max_length''', '''do_not_pad''']
									SCREAMING_SNAKE_CASE_						 = [None, 16, None]
									for max_length, padding in zip(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):
											SCREAMING_SNAKE_CASE_						 = feature_extractor(
											    SCREAMING_SNAKE_CASE_       ,       padding=SCREAMING_SNAKE_CASE_       ,       max_length=SCREAMING_SNAKE_CASE_       ,       return_attention_mask=SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = inputs.input_features
											SCREAMING_SNAKE_CASE_						 = inputs.attention_mask
											SCREAMING_SNAKE_CASE_						 = [np.sum(SCREAMING_SNAKE_CASE_    ) for x in attention_mask]

											self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]    )
											self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]    )
											self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in range(8_00       ,       14_00       ,       2_00    )]

									SCREAMING_SNAKE_CASE_						 = ['''longest''', '''max_length''', '''do_not_pad''']
									SCREAMING_SNAKE_CASE_						 = [None, 16, None]
									for max_length, padding in zip(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):
											SCREAMING_SNAKE_CASE_						 = feature_extractor(
											    SCREAMING_SNAKE_CASE_       ,       max_length=SCREAMING_SNAKE_CASE_       ,       padding=SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''       ,       return_attention_mask=SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = inputs.input_features
											SCREAMING_SNAKE_CASE_						 = inputs.attention_mask
											SCREAMING_SNAKE_CASE_						 = [np.sum(SCREAMING_SNAKE_CASE_    ) for x in attention_mask]

											self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]    )
											self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1e-6    )
											self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]    )
											self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1e-6    )
											self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in range(8_00       ,       14_00       ,       2_00    )]
									SCREAMING_SNAKE_CASE_						 = feature_extractor(
									    SCREAMING_SNAKE_CASE_       ,       padding='''max_length'''       ,       max_length=4       ,       truncation=SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''       ,       return_attention_mask=SCREAMING_SNAKE_CASE_       ,       )
									SCREAMING_SNAKE_CASE_						 = inputs.input_features
									SCREAMING_SNAKE_CASE_						 = inputs.attention_mask
									SCREAMING_SNAKE_CASE_						 = np.sum(attention_mask == 1       ,       axis=1    )

									self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]    )
									self._check_zero_mean_unit_variance(input_features[1]    )
									self._check_zero_mean_unit_variance(input_features[2]    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in range(8_00       ,       14_00       ,       2_00    )]
									SCREAMING_SNAKE_CASE_						 = feature_extractor(
									    SCREAMING_SNAKE_CASE_       ,       padding='''longest'''       ,       max_length=4       ,       truncation=SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''       ,       return_attention_mask=SCREAMING_SNAKE_CASE_       ,       )
									SCREAMING_SNAKE_CASE_						 = inputs.input_features
									SCREAMING_SNAKE_CASE_						 = inputs.attention_mask
									SCREAMING_SNAKE_CASE_						 = np.sum(attention_mask == 1       ,       axis=1    )

									self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]    )
									self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]    )
									self._check_zero_mean_unit_variance(input_features[2]    )

									# make sure that if max_length < longest -> then pad to max_length
									self.assertEqual(input_features.shape       ,       (3, 4, 24)    )

									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in range(8_00       ,       14_00       ,       2_00    )]
									SCREAMING_SNAKE_CASE_						 = feature_extractor(
									    SCREAMING_SNAKE_CASE_       ,       padding='''longest'''       ,       max_length=16       ,       truncation=SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''       ,       return_attention_mask=SCREAMING_SNAKE_CASE_       ,       )
									SCREAMING_SNAKE_CASE_						 = inputs.input_features
									SCREAMING_SNAKE_CASE_						 = inputs.attention_mask
									SCREAMING_SNAKE_CASE_						 = np.sum(attention_mask == 1       ,       axis=1    )

									self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]    )
									self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]    )
									self._check_zero_mean_unit_variance(input_features[2]    )

									# make sure that if max_length < longest -> then pad to max_length
									self.assertEqual(input_features.shape       ,       (3, 6, 24)    )

							def _lowercase					(self    ):

									"""simple docstring"""







									import torch

									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									SCREAMING_SNAKE_CASE_						 = np.random.rand(1_00       ,       32    ).astype(np.floataa    )
									SCREAMING_SNAKE_CASE_						 = np_speech_inputs.tolist()

									for inputs in [py_speech_inputs, np_speech_inputs]:
											SCREAMING_SNAKE_CASE_						 = feature_extractor.pad([{'''input_features''': inputs}]       ,       return_tensors='''np'''    )
											self.assertTrue(np_processed.input_features.dtype == np.floataa    )
											SCREAMING_SNAKE_CASE_						 = feature_extractor.pad([{'''input_features''': inputs}]       ,       return_tensors='''pt'''    )
											self.assertTrue(pt_processed.input_features.dtype == torch.floataa    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									from datasets import load_dataset

									SCREAMING_SNAKE_CASE_						 = load_dataset('''hf-internal-testing/librispeech_asr_dummy'''       ,       '''clean'''       ,       split='''validation'''    )
									# automatic decoding with librispeech
									SCREAMING_SNAKE_CASE_						 = ds.sort('''id'''    ).select(range(SCREAMING_SNAKE_CASE_    )    )[:num_samples]['''audio''']

									return [x["array"] for x in speech_samples]







							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = np.array([
									    -1.57_45, -1.77_13, -1.70_20, -1.60_69, -1.22_50, -1.11_05, -0.90_72, -0.82_41,
									    -1.23_10, -0.80_98, -0.33_20, -0.41_01, -0.79_85, -0.49_96, -0.82_13, -0.91_28,
									    -1.04_20, -1.12_86, -1.04_40, -0.79_99, -0.84_05, -1.22_75, -1.54_43, -1.46_25,
									]    )
									# fmt: on

									SCREAMING_SNAKE_CASE_						 = self._load_datasamples(1    )
									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									SCREAMING_SNAKE_CASE_						 = feature_extractor(SCREAMING_SNAKE_CASE_       ,       return_tensors='''pt'''    ).input_features
									self.assertEquals(input_features.shape       ,       (1, 5_84, 24)    )
									self.assertTrue(np.allclose(input_features[0, 0, :30]       ,       SCREAMING_SNAKE_CASE_       ,       atol=1e-4    )    )

"""simple docstring"""




import argparse

from transformers import BigBirdConfig, BigBirdForPreTraining, BigBirdForQuestionAnswering, load_tf_weights_in_big_bird
from transformers.utils import logging


logging.set_verbosity_info()



def        _lowerCamelCase ( __a,							__a,							__a,							__a    ):
		# Initialise PyTorch model
		SCREAMING_SNAKE_CASE_						 = BigBirdConfig.from_json_file(__a    )
		print(F'Building PyTorch model from configuration: {config}'    )

		if is_trivia_qa:
				SCREAMING_SNAKE_CASE_						 = BigBirdForQuestionAnswering(__a    )
		else:
				SCREAMING_SNAKE_CASE_						 = BigBirdForPreTraining(__a    )

		# Load weights from tf checkpoint
		load_tf_weights_in_big_bird(__a,							__a,							is_trivia_qa=__a    )

		# Save pytorch-model
		print(F'Save PyTorch model to {pytorch_dump_path}'    )
		model.save_pretrained(__a    )


if __name__ == "__main__":
						lowerCAmelCase__							=				argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    '--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
						)
						parser.add_argument(
						    '--big_bird_config_file',
						    default=None,
						    type=str,
						    required=True,
						    help=(
						        'The config json file corresponding to the pre-trained BERT model. \n'
						        'This specifies the model architecture.'
						    ),
						)
						parser.add_argument(
						    '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
						)
						parser.add_argument(
						    '--is_trivia_qa', action='store_true', help='Whether to convert a model with a trivia_qa head.'
						)
						lowerCAmelCase__							=				parser.parse_args()
						convert_tf_checkpoint_to_pytorch(
						    args.tf_checkpoint_path, args.big_bird_config_file, args.pytorch_dump_path, args.is_trivia_qa
						)