





"""simple docstring"""




import argparse
import os
import re

import tensorflow as tf
import torch

from transformers import BertConfig, BertModel
from transformers.utils import logging


logging.set_verbosity_info()
a		:					Any	      =     logging.get_logger(__name__)






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       Union[str, Any]       ,			_lowercase		:       Union[str, Any]       ,			_lowercase		:       Any   )					->List[Any]:






	'''simple docstring'''






	a :						Optional[Any]      =							os.path.abspath(_lowercase   )
	logger.info(F"""Converting TensorFlow checkpoint from {tf_path}"""   )
	# Load weights from TF model
	a :						List[Any]      =							tf.train.list_variables(_lowercase   )
	a :						Any      =							[]
	a :						Any      =							[]
	a :						List[str]      =							[]
	for full_name, shape in init_vars:
		# logger.info(f"Loading TF weight {name} with shape {shape}")
		a :						Optional[int]      =							full_name.split("/"   )
		if full_name == "_CHECKPOINTABLE_OBJECT_GRAPH" or name[0] in ["global_step", "save_counter"]:
			logger.info(F"""Skipping non-model layer {full_name}"""   )
			continue
		if "optimizer" in full_name:
			logger.info(F"""Skipping optimization layer {full_name}"""   )
			continue
		if name[0] == "model":
			# ignore initial 'model'
			a :						Dict      =							name[1:]
		# figure out how many levels deep the name is
		a :						List[str]      =							0
		for _name in name:
			if _name.startswith("layer_with_weights"   ):
				depth += 1
			else:
				break
		layer_depth.append(_lowercase   )
		# read data
		a :						Optional[int]      =							tf.train.load_variable(_lowercase       ,			_lowercase   )
		names.append("/".join(_lowercase   )   )
		arrays.append(_lowercase   )
	logger.info(F"""Read a total of {len(_lowercase   ):,} layers"""   )

	# Sanity check
	if len(set(_lowercase   )   ) != 1:
		raise ValueError(F"""Found layer names with different depths (layer depth {list(set(_lowercase   )   )})"""   )
	a :						Optional[int]      =							list(set(_lowercase   )   )[0]
	if layer_depth != 1:
		raise ValueError(
		    "The model contains more than just the embedding/encoder layers. This script does not handle MLM/NSP"
		    " heads."   )

	# convert layers
	logger.info("Converting weights..."   )
	for full_name, array in zip(_lowercase       ,			_lowercase   ):
		a :						Dict      =							full_name.split("/"   )
		a :						List[Any]      =							model
		a :						Tuple      =							[]
		for i, m_name in enumerate(_lowercase   ):
			if m_name == ".ATTRIBUTES":
				# variable names end with .ATTRIBUTES/VARIABLE_VALUE
				break
			if m_name.startswith("layer_with_weights"   ):
				a :						Tuple      =							int(m_name.split("-"   )[-1]   )
				if layer_num <= 2:
					# embedding layers
					# layer_num 0: word_embeddings
					# layer_num 1: position_embeddings
					# layer_num 2: token_type_embeddings
					continue
				elif layer_num == 3:
					# embedding LayerNorm
					trace.extend(["embeddings", "LayerNorm"]   )
					a :						Any      =							getattr(_lowercase       ,			"embeddings"   )
					a :						List[Any]      =							getattr(_lowercase       ,			"LayerNorm"   )
				elif layer_num > 3 and layer_num < config.num_hidden_layers + 4:
					# encoder layers
					trace.extend(["encoder", "layer", str(layer_num - 4   )]   )
					a :						Any      =							getattr(_lowercase       ,			"encoder"   )
					a :						Optional[Any]      =							getattr(_lowercase       ,			"layer"   )
					a :						Union[str, Any]      =							pointer[layer_num - 4]
				elif layer_num == config.num_hidden_layers + 4:
					# pooler layer
					trace.extend(["pooler", "dense"]   )
					a :						List[Any]      =							getattr(_lowercase       ,			"pooler"   )
					a :						int      =							getattr(_lowercase       ,			"dense"   )
			elif m_name == "embeddings":
				trace.append("embeddings"   )
				a :						Any      =							getattr(_lowercase       ,			"embeddings"   )
				if layer_num == 0:
					trace.append("word_embeddings"   )
					a :						Union[str, Any]      =							getattr(_lowercase       ,			"word_embeddings"   )
				elif layer_num == 1:
					trace.append("position_embeddings"   )
					a :						Union[str, Any]      =							getattr(_lowercase       ,			"position_embeddings"   )
				elif layer_num == 2:
					trace.append("token_type_embeddings"   )
					a :						Any      =							getattr(_lowercase       ,			"token_type_embeddings"   )
				else:
					raise ValueError(F"""Unknown embedding layer with name {full_name}"""   )
				trace.append("weight"   )
				a :						int      =							getattr(_lowercase       ,			"weight"   )
			elif m_name == "_attention_layer":
				# self-attention layer
				trace.extend(["attention", "self"]   )
				a :						List[Any]      =							getattr(_lowercase       ,			"attention"   )
				a :						Any      =							getattr(_lowercase       ,			"self"   )
			elif m_name == "_attention_layer_norm":
				# output attention norm
				trace.extend(["attention", "output", "LayerNorm"]   )
				a :						str      =							getattr(_lowercase       ,			"attention"   )
				a :						int      =							getattr(_lowercase       ,			"output"   )
				a :						str      =							getattr(_lowercase       ,			"LayerNorm"   )
			elif m_name == "_attention_output_dense":
				# output attention dense
				trace.extend(["attention", "output", "dense"]   )
				a :						List[Any]      =							getattr(_lowercase       ,			"attention"   )
				a :						Optional[int]      =							getattr(_lowercase       ,			"output"   )
				a :						int      =							getattr(_lowercase       ,			"dense"   )
			elif m_name == "_output_dense":
				# output dense
				trace.extend(["output", "dense"]   )
				a :						Union[str, Any]      =							getattr(_lowercase       ,			"output"   )
				a :						Dict      =							getattr(_lowercase       ,			"dense"   )
			elif m_name == "_output_layer_norm":
				# output dense
				trace.extend(["output", "LayerNorm"]   )
				a :						Any      =							getattr(_lowercase       ,			"output"   )
				a :						str      =							getattr(_lowercase       ,			"LayerNorm"   )
			elif m_name == "_key_dense":
				# attention key
				trace.append("key"   )
				a :						List[str]      =							getattr(_lowercase       ,			"key"   )
			elif m_name == "_query_dense":
				# attention query
				trace.append("query"   )
				a :						List[str]      =							getattr(_lowercase       ,			"query"   )
			elif m_name == "_value_dense":
				# attention value
				trace.append("value"   )
				a :						Optional[int]      =							getattr(_lowercase       ,			"value"   )
			elif m_name == "_intermediate_dense":
				# attention intermediate dense
				trace.extend(["intermediate", "dense"]   )
				a :						Optional[Any]      =							getattr(_lowercase       ,			"intermediate"   )
				a :						str      =							getattr(_lowercase       ,			"dense"   )
			elif m_name == "_output_layer_norm":
				# output layer norm
				trace.append("output"   )
				a :						str      =							getattr(_lowercase       ,			"output"   )
			# weights & biases
			elif m_name in ["bias", "beta"]:
				trace.append("bias"   )
				a :						Optional[Any]      =							getattr(_lowercase       ,			"bias"   )
			elif m_name in ["kernel", "gamma"]:
				trace.append("weight"   )
				a :						str      =							getattr(_lowercase       ,			"weight"   )
			else:
				logger.warning(F"""Ignored {m_name}"""   )
        # for certain layers reshape is necessary
		a :						List[Any]      =							".".join(_lowercase   )
		if re.match(R"(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)"       ,			_lowercase   ) or re.match(
		    R"(\S+)\.attention\.output\.dense\.weight"       ,			_lowercase   ):
			a :						str      =							array.reshape(pointer.data.shape   )
		if "kernel" in full_name:
			a :						str      =							array.transpose()
		if pointer.shape == array.shape:
			a :						Tuple      =							torch.from_numpy(_lowercase   )
		else:
			raise ValueError(
			    F"""Shape mismatch in layer {full_name}: Model expects shape {pointer.shape} but layer contains shape:"""
			    F""" {array.shape}"""   )
		logger.info(F"""Successfully set variable {full_name} to PyTorch layer {trace}"""   )
	return model






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       Union[str, Any]       ,			_lowercase		:       Union[str, Any]       ,			_lowercase		:       List[Any]   )					->List[Any]:






	'''simple docstring'''






	logger.info(F"""Loading model based on config from {config_path}..."""   )
	a :						Optional[Any]      =							BertConfig.from_json_file(_lowercase   )
	a :						Tuple      =							BertModel(_lowercase   )

	# Load weights from checkpoint
	logger.info(F"""Loading weights from checkpoint {tf_checkpoint_path}..."""   )
	load_tfa_weights_in_bert(_lowercase       ,			_lowercase       ,			_lowercase   )

	# Save pytorch-model
	logger.info(F"""Saving PyTorch model to {pytorch_dump_path}..."""   )
	torch.save(model.state_dict()       ,			_lowercase   )


if __name__ == "__main__":
		a		:					Optional[int]	      =     argparse.ArgumentParser()
		parser.add_argument(
		    '''--tf_checkpoint_path''', type=str, required=True, help='''Path to the TensorFlow 2.x checkpoint path.'''
		)
		parser.add_argument(
		    '''--bert_config_file''',
		    type=str,
		    required=True,
		    help='''The config json file corresponding to the BERT model. This specifies the model architecture.''',
		)
		parser.add_argument(
		    '''--pytorch_dump_path''',
		    type=str,
		    required=True,
		    help='''Path to the output PyTorch model (must include filename).''',
		)
		a		:					Optional[Any]	      =     parser.parse_args()
		convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)









"""simple docstring"""




import functools
import operator

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


a		:					List[Any]	      =     logging.get_logger(__name__)

a		:					List[Any]	      =     {
    '''microsoft/unispeech-sat-base-100h-libri-ft''': (
        '''https://huggingface.co/microsoft/unispeech-sat-base-100h-libri-ft/resolve/main/config.json'''
    ),
    # See all UniSpeechSat models at https://huggingface.co/models?filter=unispeech_sat
}


class 			__UpperCamelCase							(		a__		):
							lowerCamelCase  :   Tuple    ="""unispeech-sat"""






							def __init__(  self ,   lowerCAmelCase__=32 ,   lowerCAmelCase__=768 ,   lowerCAmelCase__=12 ,   lowerCAmelCase__=12 ,   lowerCAmelCase__=3072 ,   lowerCAmelCase__="gelu" ,   lowerCAmelCase__=0.1 ,   lowerCAmelCase__=0.1 ,   lowerCAmelCase__=0.1 ,   lowerCAmelCase__=0.0 ,   lowerCAmelCase__=0.0 ,   lowerCAmelCase__=0.1 ,   lowerCAmelCase__=0.1 ,   lowerCAmelCase__=0.02 ,   lowerCAmelCase__=1E-5 ,   lowerCAmelCase__="group" ,   lowerCAmelCase__="gelu" ,   lowerCAmelCase__=(512, 512, 512, 512, 512, 512, 512) ,   lowerCAmelCase__=(5, 2, 2, 2, 2, 2, 2) ,   lowerCAmelCase__=(10, 3, 3, 3, 3, 2, 2) ,   lowerCAmelCase__=False ,   lowerCAmelCase__=128 ,   lowerCAmelCase__=16 ,   lowerCAmelCase__=False ,   lowerCAmelCase__=True ,   lowerCAmelCase__=0.05 ,   lowerCAmelCase__=10 ,   lowerCAmelCase__=2 ,   lowerCAmelCase__=0.0 ,   lowerCAmelCase__=10 ,   lowerCAmelCase__=0 ,   lowerCAmelCase__=320 ,   lowerCAmelCase__=2 ,   lowerCAmelCase__=0.1 ,   lowerCAmelCase__=100 ,   lowerCAmelCase__=256 ,   lowerCAmelCase__=256 ,   lowerCAmelCase__=0.1 ,   lowerCAmelCase__="mean" ,   lowerCAmelCase__=False ,   lowerCAmelCase__=False ,   lowerCAmelCase__=256 ,   lowerCAmelCase__=(512, 512, 512, 512, 1500) ,   lowerCAmelCase__=(5, 3, 3, 1, 1) ,   lowerCAmelCase__=(1, 2, 3, 1, 1) ,   lowerCAmelCase__=512 ,   lowerCAmelCase__=0 ,   lowerCAmelCase__=1 ,   lowerCAmelCase__=2 ,   lowerCAmelCase__=504 ,   **lowerCAmelCase__ ,   )      ->					List[str]:
								super().__init__(**lowerCAmelCase__ ,   pad_token_id=lowerCAmelCase__ ,   bos_token_id=lowerCAmelCase__ ,   eos_token_id=lowerCAmelCase__ )
								a :						Any      =							hidden_size
								a :						Tuple      =							feat_extract_norm
								a :						Tuple      =							feat_extract_activation
								a :						Dict      =							list(lowerCAmelCase__ )
								a :						int      =							list(lowerCAmelCase__ )
								a :						Optional[Any]      =							list(lowerCAmelCase__ )
								a :						int      =							conv_bias
								a :						str      =							num_conv_pos_embeddings
								a :						Dict      =							num_conv_pos_embedding_groups
								a :						Optional[int]      =							len(self.conv_dim )
								a :						int      =							num_hidden_layers
								a :						Any      =							intermediate_size
								a :						Any      =							hidden_act
								a :						List[Any]      =							num_attention_heads
								a :						Any      =							hidden_dropout
								a :						Union[str, Any]      =							attention_dropout
								a :						Tuple      =							activation_dropout
								a :						Dict      =							feat_proj_dropout
								a :						Optional[Any]      =							final_dropout
								a :						Union[str, Any]      =							layerdrop
								a :						str      =							layer_norm_eps
								a :						Optional[int]      =							initializer_range
								a :						Optional[int]      =							vocab_size
								a :						str      =							num_clusters
								a :						Any      =							do_stable_layer_norm
								a :						str      =							use_weighted_layer_sum

								if (
								    (len(self.conv_stride ) != self.num_feat_extract_layers)
								    or (len(self.conv_kernel ) != self.num_feat_extract_layers)
								    or (len(self.conv_dim ) != self.num_feat_extract_layers)
								):
									raise ValueError(
									    "Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =="
									    " `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ="
									    f""" {len(self.conv_dim )}`, `len(config.conv_stride) = {len(self.conv_stride )}`,"""
									    f""" `len(config.conv_kernel) = {len(self.conv_kernel )}`.""" )

								# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
								a :						List[Any]      =							apply_spec_augment
								a :						int      =							mask_time_prob
								a :						Optional[int]      =							mask_time_length
								a :						Dict      =							mask_time_min_masks
								a :						Optional[int]      =							mask_feature_prob
								a :						List[str]      =							mask_feature_length
								a :						Dict      =							mask_feature_min_masks

								# parameters for pretraining with codevector quantized representations
								a :						List[str]      =							num_codevectors_per_group
								a :						List[Any]      =							num_codevector_groups
								a :						Tuple      =							contrastive_logits_temperature
								a :						int      =							feat_quantizer_dropout
								a :						Optional[Any]      =							num_negatives
								a :						Optional[int]      =							codevector_dim
								a :						Tuple      =							proj_codevector_dim
								a :						Optional[int]      =							diversity_loss_weight

								# ctc loss
								a :						Dict      =							ctc_loss_reduction
								a :						Optional[Any]      =							ctc_zero_infinity

								# SequenceClassification-specific parameter. Feel free to ignore for other classes.
								a :						Dict      =							classifier_proj_size

								# XVector-specific parameters. Feel free to ignore for other classes.
								a :						Union[str, Any]      =							list(lowerCAmelCase__ )
								a :						List[str]      =							list(lowerCAmelCase__ )
								a :						Tuple      =							list(lowerCAmelCase__ )
								a :						Optional[int]      =							xvector_output_dim






							@property
							def        __a  (  self )      ->					Any:
								return functools.reduce(operator.mul ,   self.conv_stride ,   1 )


