



"""simple docstring"""






import argparse

import torch

from transformers import (
    SpeechTaConfig,
    SpeechTaFeatureExtractor,
    SpeechTaForSpeechToSpeech,
    SpeechTaForSpeechToText,
    SpeechTaForTextToSpeech,
    SpeechTaProcessor,
    SpeechTaTokenizer,
    logging,
)
from transformers.tokenization_utils import AddedToken


logging.set_verbosity_info()
__snake_case							:   Tuple      =    logging.get_logger('transformers.models.speecht5')

__snake_case							:   Any      =    {
    'speech_encoder_prenet.layer_norm': 'speecht5.encoder.prenet.feature_projection.layer_norm',
    'speech_encoder_prenet.post_extract_proj': 'speecht5.encoder.prenet.feature_projection.projection',
    'speech_encoder_prenet.pos_conv.0': 'speecht5.encoder.prenet.pos_conv_embed.conv',
    'speech_encoder_prenet.mask_emb': 'speecht5.encoder.prenet.masked_spec_embed',
}
__snake_case							:   Union[str, Any]      =    {
    'text_encoder_prenet.encoder_prenet.0': 'speecht5.encoder.prenet.embed_tokens',
    'text_encoder_prenet.encoder_prenet.1.alpha': 'speecht5.encoder.prenet.encode_positions.alpha',
}
__snake_case							:   Union[str, Any]      =    {
    'speech_decoder_prenet.decoder_prenet.0.0.prenet.0.0': 'speecht5.decoder.prenet.layers.0',
    'speech_decoder_prenet.decoder_prenet.0.0.prenet.1.0': 'speecht5.decoder.prenet.layers.1',
    'speech_decoder_prenet.decoder_prenet.0.1': 'speecht5.decoder.prenet.final_layer',
    'speech_decoder_prenet.decoder_prenet.1.alpha': 'speecht5.decoder.prenet.encode_positions.alpha',
    'speech_decoder_prenet.spkembs_layer.0': 'speecht5.decoder.prenet.speaker_embeds_layer',
}
__snake_case							:   Dict      =    {
    'speech_decoder_postnet.feat_out': 'speech_decoder_postnet.feat_out',
    'speech_decoder_postnet.prob_out': 'speech_decoder_postnet.prob_out',
    'speech_decoder_postnet.postnet.postnet.0.0': 'speech_decoder_postnet.layers.0.conv',
    'speech_decoder_postnet.postnet.postnet.0.1': 'speech_decoder_postnet.layers.0.batch_norm',
    'speech_decoder_postnet.postnet.postnet.1.0': 'speech_decoder_postnet.layers.1.conv',
    'speech_decoder_postnet.postnet.postnet.1.1': 'speech_decoder_postnet.layers.1.batch_norm',
    'speech_decoder_postnet.postnet.postnet.2.0': 'speech_decoder_postnet.layers.2.conv',
    'speech_decoder_postnet.postnet.postnet.2.1': 'speech_decoder_postnet.layers.2.batch_norm',
    'speech_decoder_postnet.postnet.postnet.3.0': 'speech_decoder_postnet.layers.3.conv',
    'speech_decoder_postnet.postnet.postnet.3.1': 'speech_decoder_postnet.layers.3.batch_norm',
    'speech_decoder_postnet.postnet.postnet.4.0': 'speech_decoder_postnet.layers.4.conv',
    'speech_decoder_postnet.postnet.postnet.4.1': 'speech_decoder_postnet.layers.4.batch_norm',
}
__snake_case							:   Optional[int]      =    {
    'text_decoder_prenet.embed_tokens': 'speecht5.decoder.prenet.embed_tokens',
}
__snake_case							:   Union[str, Any]      =    {
    'text_decoder_postnet.output_projection': 'text_decoder_postnet.lm_head',
}
__snake_case							:   Tuple      =    {
    'encoder.layers.*.self_attn.k_proj': 'speecht5.encoder.wrapped_encoder.layers.*.attention.k_proj',
    'encoder.layers.*.self_attn.v_proj': 'speecht5.encoder.wrapped_encoder.layers.*.attention.v_proj',
    'encoder.layers.*.self_attn.q_proj': 'speecht5.encoder.wrapped_encoder.layers.*.attention.q_proj',
    'encoder.layers.*.self_attn.out_proj': 'speecht5.encoder.wrapped_encoder.layers.*.attention.out_proj',
    'encoder.layers.*.self_attn_layer_norm': 'speecht5.encoder.wrapped_encoder.layers.*.layer_norm',
    'encoder.layers.*.fc1': 'speecht5.encoder.wrapped_encoder.layers.*.feed_forward.intermediate_dense',
    'encoder.layers.*.fc2': 'speecht5.encoder.wrapped_encoder.layers.*.feed_forward.output_dense',
    'encoder.layers.*.final_layer_norm': 'speecht5.encoder.wrapped_encoder.layers.*.final_layer_norm',
    'encoder.layer_norm': 'speecht5.encoder.wrapped_encoder.layer_norm',
    'encoder.pos_emb.pe_k': 'speecht5.encoder.wrapped_encoder.embed_positions.pe_k',
}
__snake_case							:   str      =    {
    'decoder.layers.*.self_attn.k_proj': 'speecht5.decoder.wrapped_decoder.layers.*.self_attn.k_proj',
    'decoder.layers.*.self_attn.v_proj': 'speecht5.decoder.wrapped_decoder.layers.*.self_attn.v_proj',
    'decoder.layers.*.self_attn.q_proj': 'speecht5.decoder.wrapped_decoder.layers.*.self_attn.q_proj',
    'decoder.layers.*.self_attn.out_proj': 'speecht5.decoder.wrapped_decoder.layers.*.self_attn.out_proj',
    'decoder.layers.*.self_attn_layer_norm': 'speecht5.decoder.wrapped_decoder.layers.*.self_attn_layer_norm',
    'decoder.layers.*.encoder_attn.k_proj': 'speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.k_proj',
    'decoder.layers.*.encoder_attn.v_proj': 'speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.v_proj',
    'decoder.layers.*.encoder_attn.q_proj': 'speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.q_proj',
    'decoder.layers.*.encoder_attn.out_proj': 'speecht5.decoder.wrapped_decoder.layers.*.encoder_attn.out_proj',
    'decoder.layers.*.encoder_attn_layer_norm': 'speecht5.decoder.wrapped_decoder.layers.*.encoder_attn_layer_norm',
    'decoder.layers.*.fc1': 'speecht5.decoder.wrapped_decoder.layers.*.feed_forward.intermediate_dense',
    'decoder.layers.*.fc2': 'speecht5.decoder.wrapped_decoder.layers.*.feed_forward.output_dense',
    'decoder.layers.*.final_layer_norm': 'speecht5.decoder.wrapped_decoder.layers.*.final_layer_norm',
}
__snake_case							:   Union[str, Any]      =    {
    **MAPPING_SPEECH_ENCODER_PRENET,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
    **MAPPING_TEXT_DECODER_PRENET,
    **MAPPING_TEXT_DECODER_POSTNET,
}
__snake_case							:   str      =    {
    **MAPPING_TEXT_ENCODER_PRENET,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
    **MAPPING_SPEECH_DECODER_PRENET,
    **MAPPING_SPEECH_DECODER_POSTNET,
}
__snake_case							:   str      =    {
    **MAPPING_SPEECH_ENCODER_PRENET,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
    **MAPPING_SPEECH_DECODER_PRENET,
    **MAPPING_SPEECH_DECODER_POSTNET,
}
__snake_case							:   Optional[int]      =    []
__snake_case							:   str      =    [
    'encoder.version',
    'encoder.layers.*.norm_k.weight',
    'encoder.layers.*.norm_k.bias',
    'decoder.version',
    'decoder.layers.*.norm_k.weight',
    'decoder.layers.*.norm_k.bias',
    'decoder.pos_emb.pe_k',
    'speech_encoder_prenet.embed_positions._float_tensor',
    'text_decoder_prenet.embed_positions._float_tensor',
]
__snake_case							:   Any      =    IGNORE_KEYS + [
    'encoder.proj',
    'text_encoder_prenet.*',
    'speech_decoder_prenet.*',
    'speech_decoder_postnet.*',
]
__snake_case							:   Optional[int]      =    IGNORE_KEYS + [
    'encoder.proj',
    'speech_encoder_prenet.*',
    'text_decoder_prenet.*',
    'text_decoder_postnet.*',
]
__snake_case							:   Dict      =    IGNORE_KEYS + [
    'encoder.proj',
    'text_encoder_prenet.*',
    'text_decoder_prenet.*',
    'text_decoder_postnet.*',
]


def 			_lowercase				(  __snake_case					,__snake_case					,__snake_case					,__snake_case					,__snake_case	)						->   Dict:
			for attribute in key.split("."	):
						__lowerCAmelCase      :  Tuple												=       getattr(__snake_case					,__snake_case	)

			if weight_type is not None:
						__lowerCAmelCase      :  Tuple												=       getattr(__snake_case					,__snake_case	).shape
			else:
						__lowerCAmelCase      :  Optional[Any]												=       hf_pointer.shape

			if hf_shape != value.shape:
						raise ValueError(
						    F"""Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"""
						    F""" {value.shape} for {full_name}"""	)

			if weight_type == "weight":
						__lowerCAmelCase      :  Optional[int]												=       value
			elif weight_type == "weight_g":
						__lowerCAmelCase      :  Tuple												=       value
			elif weight_type == "weight_v":
						__lowerCAmelCase      :  str												=       value
			elif weight_type == "bias":
						__lowerCAmelCase      :  int												=       value
			elif weight_type == "running_mean":
						__lowerCAmelCase      :  List[Any]												=       value
			elif weight_type == "running_var":
						__lowerCAmelCase      :  Union[str, Any]												=       value
			elif weight_type == "num_batches_tracked":
						__lowerCAmelCase      :  Union[str, Any]												=       value
			else:
						__lowerCAmelCase      :  List[str]												=       value

			logger.info(F"""{key + ('.' + weight_type if weight_type is not None else '')} was initialized from {full_name}."""	)


def 			_lowercase				(  __snake_case					,__snake_case	)						->   Optional[int]:
			for key in ignore_keys:
						if key.endswith(".*"	):
									if name.startswith(key[:-1]	):
												return True
						elif ".*." in key:
									__lowerCAmelCase						,	__lowerCAmelCase      :  Any												=       key.split(".*."	)
									if prefix in name and suffix in name:
												return True
						elif key in name:
									return True
			return False


def 			_lowercase				(  __snake_case					,__snake_case					,__snake_case	)						->   int:
			__lowerCAmelCase      :  Optional[Any]												=       []

			if task == "s2t":
						__lowerCAmelCase      :  List[str]												=       hf_model.speechta.encoder.prenet.feature_encoder
						__lowerCAmelCase      :  Tuple												=       MAPPING_S2T
						__lowerCAmelCase      :  List[Any]												=       IGNORE_KEYS_S2T
			elif task == "t2s":
						__lowerCAmelCase      :  Any												=       None
						__lowerCAmelCase      :  List[Any]												=       MAPPING_T2S
						__lowerCAmelCase      :  Optional[int]												=       IGNORE_KEYS_T2S
			elif task == "s2s":
						__lowerCAmelCase      :  str												=       hf_model.speechta.encoder.prenet.feature_encoder
						__lowerCAmelCase      :  Any												=       MAPPING_S2S
						__lowerCAmelCase      :  Any												=       IGNORE_KEYS_S2S
			else:
						raise ValueError(F"""Unsupported task: {task}"""	)

			for name, value in fairseq_dict.items():
						if should_ignore(__snake_case					,__snake_case	):
									logger.info(F"""{name} was ignored"""	)
									continue

						__lowerCAmelCase      :  Union[str, Any]												=       False
						if "conv_layers" in name:
									load_conv_layer(
									    __snake_case					,__snake_case					,__snake_case					,__snake_case					,hf_model.config.feat_extract_norm == "group"					,)
									__lowerCAmelCase      :  List[Any]												=       True
						else:
									for key, mapped_key in MAPPING.items():
												# mapped_key = "speecht5." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key

												if "*" in key:
															__lowerCAmelCase						,	__lowerCAmelCase      :  List[str]												=       key.split(".*."	)
															if prefix in name and suffix in name:
																		__lowerCAmelCase      :  Optional[Any]												=       suffix

                # if key in name or key.split("w2v_model.")[-1] == name.split(".")[0]:
												if key in name:
															__lowerCAmelCase      :  Union[str, Any]												=       True
															if "*" in mapped_key:
																		__lowerCAmelCase      :  Tuple												=       name.split(__snake_case	)[0].split("."	)[-2]
																		__lowerCAmelCase      :  int												=       mapped_key.replace("*"					,__snake_case	)
															if "weight_g" in name:
																		__lowerCAmelCase      :  List[str]												=       "weight_g"
															elif "weight_v" in name:
																		__lowerCAmelCase      :  List[Any]												=       "weight_v"
															elif "bias" in name:
																		__lowerCAmelCase      :  List[str]												=       "bias"
															elif "weight" in name:
																		__lowerCAmelCase      :  List[str]												=       "weight"
															elif "running_mean" in name:
																		__lowerCAmelCase      :  Optional[Any]												=       "running_mean"
															elif "running_var" in name:
																		__lowerCAmelCase      :  Optional[int]												=       "running_var"
															elif "num_batches_tracked" in name:
																		__lowerCAmelCase      :  Optional[int]												=       "num_batches_tracked"
															else:
																		__lowerCAmelCase      :  Dict												=       None
															set_recursively(__snake_case					,__snake_case					,__snake_case					,__snake_case					,__snake_case	)
												continue
						if not is_used:
									unused_weights.append(__snake_case	)

			logger.warning(F"""Unused weights: {unused_weights}"""	)


def 			_lowercase				(  __snake_case					,__snake_case					,__snake_case					,__snake_case					,__snake_case	)						->   Tuple:
			__lowerCAmelCase      :  Any												=       full_name.split("conv_layers."	)[-1]
			__lowerCAmelCase      :  List[str]												=       name.split("."	)
			__lowerCAmelCase      :  int												=       int(items[0]	)
			__lowerCAmelCase      :  Optional[Any]												=       int(items[1]	)

			if type_id == 0:
						if "bias" in name:
									if value.shape != feature_extractor.conv_layers[layer_id].conv.bias.data.shape:
												raise ValueError(
												    F"""{full_name} has size {value.shape}, but"""
												    F""" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."""	)
									__lowerCAmelCase      :  Any												=       value
									logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}."""	)
						elif "weight" in name:
									if value.shape != feature_extractor.conv_layers[layer_id].conv.weight.data.shape:
												raise ValueError(
												    F"""{full_name} has size {value.shape}, but"""
												    F""" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."""	)
									__lowerCAmelCase      :  Optional[Any]												=       value
									logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}."""	)
			elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
						if "bias" in name:
									if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape:
												raise ValueError(
												    F"""{full_name} has size {value.shape}, but"""
												    F""" {feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape} was found."""	)
									__lowerCAmelCase      :  Dict												=       value
									logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""	)
						elif "weight" in name:
									if value.shape != feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape:
												raise ValueError(
												    F"""{full_name} has size {value.shape}, but"""
												    F""" {feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape} was found."""	)
									__lowerCAmelCase      :  Union[str, Any]												=       value
									logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""	)
			else:
						unused_weights.append(__snake_case	)


@torch.no_grad()
def 			_lowercase				(  __snake_case					,__snake_case					,__snake_case					,__snake_case=None					,__snake_case=None					,__snake_case=None					,)						->   Tuple:
			if config_path is not None:
						__lowerCAmelCase      :  int												=       SpeechTaConfig.from_pretrained(__snake_case	)
			else:
						__lowerCAmelCase      :  Union[str, Any]												=       SpeechTaConfig()

			if task == "s2t":
						__lowerCAmelCase      :  int												=       config.max_text_positions
						__lowerCAmelCase      :  Tuple												=       SpeechTaForSpeechToText(__snake_case	)
			elif task == "t2s":
						__lowerCAmelCase      :  Optional[Any]												=       1_876
						__lowerCAmelCase      :  Optional[int]												=       600
						__lowerCAmelCase      :  Any												=       config.max_speech_positions
						__lowerCAmelCase      :  str												=       SpeechTaForTextToSpeech(__snake_case	)
			elif task == "s2s":
						__lowerCAmelCase      :  str												=       1_876
						__lowerCAmelCase      :  Optional[int]												=       config.max_speech_positions
						__lowerCAmelCase      :  Union[str, Any]												=       SpeechTaForSpeechToSpeech(__snake_case	)
			else:
						raise ValueError(F"""Unknown task name: {task}"""	)

			if vocab_path:
						__lowerCAmelCase      :  Any												=       SpeechTaTokenizer(__snake_case					,model_max_length=config.max_text_positions	)

						# Mask token behaves like a normal word, i.e. include the space before it
						__lowerCAmelCase      :  Tuple												=       AddedToken("<mask>"					,lstrip=__snake_case					,rstrip=__snake_case	)
						__lowerCAmelCase      :  Union[str, Any]												=       mask_token
						tokenizer.add_special_tokens({"mask_token": mask_token}	)
						tokenizer.add_tokens(["<ctc_blank>"]	)

			__lowerCAmelCase      :  List[str]												=       SpeechTaFeatureExtractor()
			__lowerCAmelCase      :  List[Any]												=       SpeechTaProcessor(tokenizer=__snake_case					,feature_extractor=__snake_case	)
			processor.save_pretrained(__snake_case	)

			__lowerCAmelCase      :  List[Any]												=       torch.load(__snake_case	)
			recursively_load_weights(fairseq_checkpoint["model"]					,__snake_case					,__snake_case	)

			model.save_pretrained(__snake_case	)

			if repo_id:
						print("Pushing to the hub..."	)
						processor.push_to_hub(__snake_case	)
						model.push_to_hub(__snake_case	)


if __name__ == "__main__":
	__snake_case							:   Any      =    argparse.ArgumentParser()
	parser.add_argument(
	    '--task',
	    default='s2t',
	    type=str,
	    help='Type of the SpeechT5 model you\'d like to convert. Should be one of \'s2t\', \'t2s\', \'s2s\'.',
	)
	parser.add_argument('--checkpoint_path', required=True, default=None, type=str, help='Path to fairseq checkpoint')
	parser.add_argument('--vocab_path', default=None, type=str, help='Path to SentencePiece model')
	parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert')
	parser.add_argument(
	    '--pytorch_dump_folder_path', required=True, default=None, type=str, help='Path to the output PyTorch model.'
	)
	parser.add_argument(
	    '--push_to_hub', default=None, type=str, help='Where to upload the converted model on the 🤗 hub.'
	)

	__snake_case							:   Any      =    parser.parse_args()
	convert_speechta_checkpoint(
	    args.task,
	    args.checkpoint_path,
	    args.pytorch_dump_folder_path,
	    args.config_path,
	    args.vocab_path,
	    args.push_to_hub,
	)




"""simple docstring"""






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


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

__snake_case							:   Any      =    {
    'speechbrain/m-ctc-t-large': 'https://huggingface.co/speechbrain/m-ctc-t-large/resolve/main/config.json',
    # See all M-CTC-T models at https://huggingface.co/models?filter=mctct
}



class 			A__   (  __SCREAMING_SNAKE_CASE							):




	'''simple docstring'''





	SCREAMING_SNAKE_CASE          =	'mctct'

	def __init__(     self:		Union[str, Any]       ,			_SCREAMING_SNAKE_CASE:		str=8065       ,			_SCREAMING_SNAKE_CASE:		str=1536       ,			_SCREAMING_SNAKE_CASE:		str=36       ,			_SCREAMING_SNAKE_CASE:		Optional[Any]=6144       ,			_SCREAMING_SNAKE_CASE:		Optional[Any]=4       ,			_SCREAMING_SNAKE_CASE:		Union[str, Any]=384       ,			_SCREAMING_SNAKE_CASE:		Optional[Any]=920       ,			_SCREAMING_SNAKE_CASE:		Union[str, Any]=1e-5       ,			_SCREAMING_SNAKE_CASE:		List[Any]=0.3       ,			_SCREAMING_SNAKE_CASE:		Optional[Any]="relu"       ,			_SCREAMING_SNAKE_CASE:		Optional[int]=0.02       ,			_SCREAMING_SNAKE_CASE:		Optional[Any]=0.3       ,			_SCREAMING_SNAKE_CASE:		Dict=0.3       ,			_SCREAMING_SNAKE_CASE:		List[Any]=1       ,			_SCREAMING_SNAKE_CASE:		Optional[Any]=0       ,			_SCREAMING_SNAKE_CASE:		List[str]=2       ,			_SCREAMING_SNAKE_CASE:		Union[str, Any]=1       ,			_SCREAMING_SNAKE_CASE:		Tuple=0.3       ,			_SCREAMING_SNAKE_CASE:		Dict=1       ,			_SCREAMING_SNAKE_CASE:		int=(7,)       ,			_SCREAMING_SNAKE_CASE:		str=(3,)       ,			_SCREAMING_SNAKE_CASE:		Union[str, Any]=80       ,			_SCREAMING_SNAKE_CASE:		Tuple=1       ,			_SCREAMING_SNAKE_CASE:		Dict=None       ,			_SCREAMING_SNAKE_CASE:		Tuple="sum"       ,			_SCREAMING_SNAKE_CASE:		List[str]=False       ,			**_SCREAMING_SNAKE_CASE:		Tuple       ,			)				->       Tuple:

				"""simple docstring"""

				super().__init__(**_SCREAMING_SNAKE_CASE       ,			pad_token_id=_SCREAMING_SNAKE_CASE       ,			bos_token_id=_SCREAMING_SNAKE_CASE       ,			eos_token_id=_SCREAMING_SNAKE_CASE)
				__lowerCAmelCase      :  str												=       vocab_size
				__lowerCAmelCase      :  str												=       hidden_size
				__lowerCAmelCase      :  str												=       num_hidden_layers
				__lowerCAmelCase      :  str												=       intermediate_size
				__lowerCAmelCase      :  List[Any]												=       num_attention_heads
				__lowerCAmelCase      :  Dict												=       attention_head_dim
				__lowerCAmelCase      :  Optional[int]												=       max_position_embeddings
				__lowerCAmelCase      :  str												=       layer_norm_eps
				__lowerCAmelCase      :  Tuple												=       layerdrop
				__lowerCAmelCase      :  str												=       hidden_act
				__lowerCAmelCase      :  List[Any]												=       initializer_range
				__lowerCAmelCase      :  int												=       hidden_dropout_prob
				__lowerCAmelCase      :  Optional[Any]												=       attention_probs_dropout_prob
				__lowerCAmelCase      :  str												=       pad_token_id
				__lowerCAmelCase      :  Optional[int]												=       bos_token_id
				__lowerCAmelCase      :  Union[str, Any]												=       eos_token_id
				__lowerCAmelCase      :  Any												=       conv_glu_dim
				__lowerCAmelCase      :  Optional[int]												=       conv_dropout
				__lowerCAmelCase      :  Union[str, Any]												=       num_conv_layers
				__lowerCAmelCase      :  Optional[int]												=       input_feat_per_channel
				__lowerCAmelCase      :  Union[str, Any]												=       input_channels
				__lowerCAmelCase      :  Optional[Any]												=       conv_channels
				__lowerCAmelCase      :  Dict												=       ctc_loss_reduction
				__lowerCAmelCase      :  int												=       ctc_zero_infinity

				# prevents config testing fail with exporting to json
				__lowerCAmelCase      :  List[str]												=       list(_SCREAMING_SNAKE_CASE)
				__lowerCAmelCase      :  Dict												=       list(_SCREAMING_SNAKE_CASE)

				if len(self.conv_kernel) != self.num_conv_layers:
							raise ValueError(
							    "Configuration for convolutional module is incorrect. "
							    "It is required that `len(config.conv_kernel)` == `config.num_conv_layers` "
							    F"""but is `len(config.conv_kernel) = {len(self.conv_kernel)}`, """
							    F"""`config.num_conv_layers = {self.num_conv_layers}`.""")