




"""simple docstring"""




from __future__ import annotations

import unittest

from transformers import LEDConfig, 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import TFLEDForConditionalGeneration, TFLEDModel






@require_tf
class 					__magic_name__							:






				'''simple docstring'''
				__UpperCamelCase    						=		LEDConfig
				__UpperCamelCase    						=		{}
				__UpperCamelCase    						=		"gelu"





				def __init__( self	,				_a	,				_a=13	,				_a=7	,				_a=True	,				_a=False	,				_a=99	,				_a=32	,				_a=2	,				_a=4	,				_a=37	,				_a=0.1	,				_a=0.1	,				_a=20	,				_a=2	,				_a=1	,				_a=0	,				_a=4	,				):





							"""simple docstring"""
							lowerCamelCase       =      parent
							lowerCamelCase       =      batch_size
							lowerCamelCase       =      seq_length
							lowerCamelCase       =      is_training
							lowerCamelCase       =      use_labels
							lowerCamelCase       =      vocab_size
							lowerCamelCase       =      hidden_size
							lowerCamelCase       =      num_hidden_layers
							lowerCamelCase       =      num_attention_heads
							lowerCamelCase       =      intermediate_size

							lowerCamelCase       =      hidden_dropout_prob
							lowerCamelCase       =      attention_probs_dropout_prob
							lowerCamelCase       =      max_position_embeddings
							lowerCamelCase       =      eos_token_id
							lowerCamelCase       =      pad_token_id
							lowerCamelCase       =      bos_token_id
							lowerCamelCase       =      attention_window

							# `ModelTesterMixin.test_attention_outputs` is expecting attention tensors to be of size
							# [num_attention_heads, encoder_seq_length, encoder_key_length], but TFLongformerSelfAttention
							# returns attention of shape [num_attention_heads, encoder_seq_length, self.attention_window + 1]
							# because its local attention only attends to `self.attention_window` and one before and one after
							lowerCamelCase       =      self.attention_window + 2

							# because of padding `encoder_seq_length`, is different from `seq_length`. Relevant for
							# the `test_attention_outputs` and `test_hidden_states_output` tests
							lowerCamelCase       =      (
							    self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window
							)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      ids_tensor([self.batch_size, self.seq_length - 1]	,				self.vocab_size				)
							lowerCamelCase       =      tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size				)	,				1				)
							lowerCamelCase       =      tf.concat([input_ids, eos_tensor]	,				axis=1				)

							lowerCamelCase       =      ids_tensor([self.batch_size, self.seq_length]	,				self.vocab_size				)

							lowerCamelCase       =      self.config_cls(
							    vocab_size=self.vocab_size	,				d_model=self.hidden_size	,				encoder_layers=self.num_hidden_layers	,				decoder_layers=self.num_hidden_layers	,				encoder_attention_heads=self.num_attention_heads	,				decoder_attention_heads=self.num_attention_heads	,				encoder_ffn_dim=self.intermediate_size	,				decoder_ffn_dim=self.intermediate_size	,				dropout=self.hidden_dropout_prob	,				attention_dropout=self.attention_probs_dropout_prob	,				max_position_embeddings=self.max_position_embeddings	,				eos_token_ids=[2]	,				bos_token_id=self.bos_token_id	,				pad_token_id=self.pad_token_id	,				decoder_start_token_id=self.pad_token_id	,				attention_window=self.attention_window	,				**self.config_updates	,				)
							lowerCamelCase       =      prepare_led_inputs_dict(_a	,				_a	,				_a				)
							lowerCamelCase       =      tf.concat(
							    [tf.zeros_like(_a				)[:, :-1], tf.ones_like(_a				)[:, -1:]]	,				axis=-1	,				)
							lowerCamelCase       =      global_attention_mask
							return config, inputs_dict





				def      _lowerCAmelCase       ( self	,				_a	,				_a				):





							"""simple docstring"""
							lowerCamelCase       =      TFLEDModel(config=_a				).get_decoder()
							lowerCamelCase       =      inputs_dict["""input_ids"""]

							lowerCamelCase       =      input_ids[:1, :]
							lowerCamelCase       =      inputs_dict["""attention_mask"""][:1, :]
							lowerCamelCase       =      1

							# first forward pass
							lowerCamelCase       =      model(_a	,				attention_mask=_a	,				use_cache=_a				)

							lowerCamelCase   ,     lowerCamelCase       =      outputs.to_tuple()

							# create hypothetical next token and extent to next_input_ids
							lowerCamelCase       =      ids_tensor((self.batch_size, 3)	,				config.vocab_size				)
							lowerCamelCase       =      tf.cast(ids_tensor((self.batch_size, 3)	,				2				)	,				tf.inta				)

							# append to next input_ids and
							lowerCamelCase       =      tf.concat([input_ids, next_tokens]	,				axis=-1				)
							lowerCamelCase       =      tf.concat([attention_mask, next_attn_mask]	,				axis=-1				)

							lowerCamelCase       =      model(_a	,				attention_mask=_a				)[0]
							lowerCamelCase       =      model(_a	,				attention_mask=_a	,				past_key_values=_a				)[0]

							self.parent.assertEqual(next_tokens.shape[1]	,				output_from_past.shape[1]				)

							# select random slice
							lowerCamelCase       =      int(ids_tensor((1,)	,				output_from_past.shape[-1]				)				)
							lowerCamelCase       =      output_from_no_past[:, -3:, random_slice_idx]
							lowerCamelCase       =      output_from_past[:, :, random_slice_idx]

							# test that outputs are equal for slice
							tf.debugging.assert_near(_a	,				_a	,				rtol=1e-3				)




def 					a__				(       snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__=None ,				snake_case__=None ,				snake_case__=None ,				snake_case__=None ,				)		->      Optional[Any]:
			if attention_mask is None:
						lowerCamelCase       =      tf.cast(tf.math.not_equal(snake_case__ ,				config.pad_token_id       ) ,				tf.inta       )
			if decoder_attention_mask is None:
						lowerCamelCase       =      tf.concat(
						    [
						        tf.ones(decoder_input_ids[:, :1].shape ,				dtype=tf.inta       ),
						        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:] ,				config.pad_token_id       ) ,				tf.inta       ),
						    ] ,				axis=-1 ,				)
			if head_mask is None:
						lowerCamelCase       =      tf.ones((config.encoder_layers, config.encoder_attention_heads)       )
			if decoder_head_mask is None:
						lowerCamelCase       =      tf.ones((config.decoder_layers, config.decoder_attention_heads)       )
			return {
			    "input_ids": input_ids,
			    "attention_mask": attention_mask,
			    "decoder_input_ids": decoder_input_ids,
			    "decoder_attention_mask": decoder_attention_mask,
			    "head_mask": head_mask,
			    "decoder_head_mask": decoder_head_mask,
			}






@require_tf
class 					__magic_name__							( UpperCAmelCase__		,      UpperCAmelCase__		,      unittest.TestCase       ):






				'''simple docstring'''
				__UpperCamelCase    						=		(TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
				__UpperCamelCase    						=		(TFLEDForConditionalGeneration,) if is_tf_available() else ()
				__UpperCamelCase    						=		(
				    {
				        "conversational": TFLEDForConditionalGeneration,
				        "feature-extraction": TFLEDModel,
				        "summarization": TFLEDForConditionalGeneration,
				        "text2text-generation": TFLEDForConditionalGeneration,
				        "translation": TFLEDForConditionalGeneration,
				    }
				    if is_tf_available()
				    else {}
				)
				__UpperCamelCase    						=		True
				__UpperCamelCase    						=		False
				__UpperCamelCase    						=		False
				__UpperCamelCase    						=		False





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      TFLEDModelTester(self				)
							lowerCamelCase       =      ConfigTester(self	,				config_class=_a				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							self.config_tester.run_common_tests()





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.check_decoder_model_past_large_inputs(*_a				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase   ,     lowerCamelCase       =      self.model_tester.prepare_config_and_inputs_for_common()
							lowerCamelCase       =      tf.zeros_like(inputs_dict["""attention_mask"""]				)
							lowerCamelCase       =      2
							lowerCamelCase       =      tf.where(
							    tf.range(self.model_tester.seq_length				)[None, :] < num_global_attn_indices	,				1	,				inputs_dict["""global_attention_mask"""]	,				)

							lowerCamelCase       =      True
							lowerCamelCase       =      self.model_tester.seq_length
							lowerCamelCase       =      self.model_tester.encoder_seq_length

							def check_decoder_attentions_output(_a				):
										lowerCamelCase       =      outputs.decoder_attentions
										self.assertEqual(len(_a				)	,				self.model_tester.num_hidden_layers				)
										self.assertListEqual(
										    list(decoder_attentions[0].shape[-3:]				)	,				[self.model_tester.num_attention_heads, seq_length, seq_length]	,				)

							def check_encoder_attentions_output(_a				):
										lowerCamelCase       =      [t.numpy() for t in outputs.encoder_attentions]
										lowerCamelCase       =      [t.numpy() for t in outputs.encoder_global_attentions]
										self.assertEqual(len(_a				)	,				self.model_tester.num_hidden_layers				)
										self.assertEqual(len(_a				)	,				self.model_tester.num_hidden_layers				)
										self.assertListEqual(
										    list(attentions[0].shape[-3:]				)	,				[self.model_tester.num_attention_heads, seq_length, seq_length]	,				)
										self.assertListEqual(
										    list(global_attentions[0].shape[-3:]				)	,				[self.model_tester.num_attention_heads, encoder_seq_length, num_global_attn_indices]	,				)

							for model_class in self.all_model_classes:
										lowerCamelCase       =      True
										lowerCamelCase       =      False
										lowerCamelCase       =      False
										lowerCamelCase       =      model_class(_a				)
										lowerCamelCase       =      model(self._prepare_for_class(_a	,				_a				)				)
										lowerCamelCase       =      len(_a				)
										self.assertEqual(config.output_hidden_states	,				_a				)
										check_encoder_attentions_output(_a				)

										if self.is_encoder_decoder:
													lowerCamelCase       =      model_class(_a				)
													lowerCamelCase       =      model(self._prepare_for_class(_a	,				_a				)				)
													self.assertEqual(config.output_hidden_states	,				_a				)
													check_decoder_attentions_output(_a				)

										# Check that output attentions can also be changed via the config
										del inputs_dict["output_attentions"]
										lowerCamelCase       =      True
										lowerCamelCase       =      model_class(_a				)
										lowerCamelCase       =      model(self._prepare_for_class(_a	,				_a				)				)
										self.assertEqual(config.output_hidden_states	,				_a				)
										check_encoder_attentions_output(_a				)

										# Check attention is always last and order is fine
										lowerCamelCase       =      True
										lowerCamelCase       =      True
										lowerCamelCase       =      model_class(_a				)
										lowerCamelCase       =      model(self._prepare_for_class(_a	,				_a				)				)

										self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)	,				len(_a				)				)
										self.assertEqual(model.config.output_hidden_states	,				_a				)
										check_encoder_attentions_output(_a				)





				@unittest.skip("""LED keeps using potentially symbolic tensors in conditionals and breaks tracing."""				)
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							pass





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							# TODO: Head-masking not yet implement
							pass




def 					a__				(       snake_case__       )		->      Any:
			return tf.constant(snake_case__ ,				dtype=tf.intaa       )


lowerCAmelCase							:    Dict  							=							1e-4






@slow
@require_tf
class 					__magic_name__							( unittest.TestCase       ):






				'''simple docstring'''





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      TFLEDForConditionalGeneration.from_pretrained("""allenai/led-base-16384"""				).led

							# change to intended input here
							lowerCamelCase       =      _long_tensor([512 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]				)
							lowerCamelCase       =      _long_tensor([128 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]				)
							lowerCamelCase       =      prepare_led_inputs_dict(model.config	,				_a	,				_a				)
							lowerCamelCase       =      model(**_a				)[0]
							lowerCamelCase       =      (1, 1_024, 768)
							self.assertEqual(output.shape	,				_a				)
							# change to expected output here
							lowerCamelCase       =      tf.convert_to_tensor(
							    [[2.3_050, 2.8_279, 0.6_531], [-1.8_457, -0.1_455, -3.5_661], [-1.0_186, 0.4_586, -2.2_043]]	,				)
							tf.debugging.assert_near(output[:, :3, :3]	,				_a	,				atol=1e-3				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      TFLEDForConditionalGeneration.from_pretrained("""allenai/led-base-16384"""				)

							# change to intended input here
							lowerCamelCase       =      _long_tensor([512 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]				)
							lowerCamelCase       =      _long_tensor([128 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]				)
							lowerCamelCase       =      prepare_led_inputs_dict(model.config	,				_a	,				_a				)
							lowerCamelCase       =      model(**_a				)[0]
							lowerCamelCase       =      (1, 1_024, model.config.vocab_size)
							self.assertEqual(output.shape	,				_a				)
							# change to expected output here
							lowerCamelCase       =      tf.convert_to_tensor(
							    [[33.6_507, 6.4_572, 16.8_089], [5.8_739, -2.4_238, 11.2_902], [-3.2_139, -4.3_149, 4.2_783]]	,				)
							tf.debugging.assert_near(output[:, :3, :3]	,				_a	,				atol=1e-3	,				rtol=1e-3				)









"""simple docstring"""




import argparse
import json
import os

import fairseq
import torch
from torch import nn

from transformers import (
    SpeechaTextaConfig,
    SpeechaTextaForCausalLM,
    SpeechaTextaTokenizer,
    SpeechEncoderDecoderConfig,
    SpeechEncoderDecoderModel,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaModel,
    logging,
)


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

lowerCAmelCase							:    Optional[Any]  							=							{
    """post_extract_proj""": """feature_projection.projection""",
    """encoder.pos_conv.0""": """encoder.pos_conv_embed.conv""",
    """self_attn.k_proj""": """encoder.layers.*.attention.k_proj""",
    """self_attn.v_proj""": """encoder.layers.*.attention.v_proj""",
    """self_attn.q_proj""": """encoder.layers.*.attention.q_proj""",
    """self_attn.out_proj""": """encoder.layers.*.attention.out_proj""",
    """self_attn_layer_norm""": """encoder.layers.*.layer_norm""",
    """fc1""": """encoder.layers.*.feed_forward.intermediate_dense""",
    """fc2""": """encoder.layers.*.feed_forward.output_dense""",
    """final_layer_norm""": """encoder.layers.*.final_layer_norm""",
    """encoder.layer_norm""": """encoder.layer_norm""",
    """w2v_model.layer_norm""": """feature_projection.layer_norm""",
    """quantizer.weight_proj""": """quantizer.weight_proj""",
    """quantizer.vars""": """quantizer.codevectors""",
    """project_q""": """project_q""",
    """final_proj""": """project_hid""",
    """w2v_encoder.proj""": """lm_head""",
    """mask_emb""": """masked_spec_embed""",
}
lowerCAmelCase							:    Optional[Any]  							=							[
    """lm_head""",
    """quantizer.weight_proj""",
    """quantizer.codevectors""",
    """project_q""",
    """project_hid""",
]



def 					a__				(       snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__       )		->      List[Any]:
			for attribute in key.split("""."""       ):
						lowerCamelCase       =      getattr(snake_case__ ,				snake_case__       )

			if weight_type is not None:
						lowerCamelCase       =      getattr(snake_case__ ,				snake_case__       ).shape
			else:
						lowerCamelCase       =      hf_pointer.shape

			assert hf_shape == value.shape, (
			    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       =      value
			elif weight_type == "weight_g":
						lowerCamelCase       =      value
			elif weight_type == "weight_v":
						lowerCamelCase       =      value
			elif weight_type == "bias":
						lowerCamelCase       =      value
			else:
						lowerCamelCase       =      value

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



def 					a__				(       snake_case__ ,				snake_case__       )		->      Tuple:
			lowerCamelCase       =      []
			lowerCamelCase       =      fairseq_model.state_dict()

			lowerCamelCase       =      hf_model.feature_extractor

			# if encoder has different dim to decoder -> use proj_weight
			lowerCamelCase       =      None

			for name, value in fairseq_dict.items():
						lowerCamelCase       =      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       =      True
						elif name.split("""."""       )[0] == "proj":
									lowerCamelCase       =      fairseq_model.proj
									lowerCamelCase       =      True
						else:
									for key, mapped_key in MAPPING.items():
												if key in name or key.split("""w2v_model."""       )[-1] == name.split("""."""       )[0]:
															lowerCamelCase       =      True
															if "*" in mapped_key:
																		lowerCamelCase       =      name.split(snake_case__       )[0].split("""."""       )[-2]
																		lowerCamelCase       =      mapped_key.replace("""*""" ,				snake_case__       )
															if "weight_g" in name:
																		lowerCamelCase       =      """weight_g"""
															elif "weight_v" in name:
																		lowerCamelCase       =      """weight_v"""
															elif "bias" in name:
																		lowerCamelCase       =      """bias"""
															elif "weight" in name:
																		lowerCamelCase       =      """weight"""
															else:
																		lowerCamelCase       =      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}'       )

			return proj_weight



def 					a__				(       snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__       )		->      Optional[int]:
			lowerCamelCase       =      full_name.split("""conv_layers."""       )[-1]
			lowerCamelCase       =      name.split("""."""       )
			lowerCamelCase       =      int(items[0]       )
			lowerCamelCase       =      int(items[1]       )

			if type_id == 0:
						if "bias" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
									    F'{full_name} has size {value.shape}, but'
									    F' {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found.'
									)
									lowerCamelCase       =      value
									logger.info(F'Feat extract conv layer {layer_id} was initialized from {full_name}.'       )
						elif "weight" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
									    F'{full_name} has size {value.shape}, but'
									    F' {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found.'
									)
									lowerCamelCase       =      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:
									assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
									    F'{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was'
									    " found."
									)
									lowerCamelCase       =      value
									logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'       )
						elif "weight" in name:
									assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
									    F'{full_name} has size {value.shape}, but'
									    F' {feature_extractor[layer_id].layer_norm.weight.data.shape} was found.'
									)
									lowerCamelCase       =      value
									logger.info(F'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'       )
			else:
						unused_weights.append(snake_case__       )



def 					a__				(       snake_case__       )		->      Tuple:
			lowerCamelCase   ,     lowerCamelCase       =      emb.weight.shape
			lowerCamelCase       =      nn.Linear(snake_case__ ,				snake_case__ ,				bias=snake_case__       )
			lowerCamelCase       =      emb.weight.data
			return lin_layer



def 					a__				(       snake_case__       )		->      Optional[int]:
			with open(snake_case__ ,				"""r""" ,				encoding="""utf-8"""       ) as f:
						lowerCamelCase       =      f.readlines()
						lowerCamelCase       =      [line.split(""" """       )[0] for line in lines]

			lowerCamelCase       =      len(snake_case__       )

			lowerCamelCase       =      {
			    """<s>""": 0,
			    """<pad>""": 1,
			    """</s>""": 2,
			    """<unk>""": 3,
			}

			vocab_dict.update(dict(zip(snake_case__ ,				range(4 ,				num_words + 4       )       )       )       )
			return vocab_dict



@torch.no_grad()
def 					a__				(       snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__ ,				snake_case__ ,				)		->      Optional[int]:
			lowerCamelCase       =      WavaVecaConfig.from_pretrained(snake_case__       )
			lowerCamelCase       =      SpeechaTextaConfig.from_pretrained(
			    snake_case__ ,				vocab_size=snake_case__ ,				decoder_layers=snake_case__ ,				do_stable_layer_norm=snake_case__       )

			lowerCamelCase       =      WavaVecaFeatureExtractor(
			    feature_size=1 ,				sampling_rate=1_60_00 ,				padding_value=0 ,				do_normalize=snake_case__ ,				return_attention_mask=snake_case__ ,				)

			lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase       =      fairseq.checkpoint_utils.load_model_ensemble_and_task(
			    [checkpoint_path] ,				arg_overrides={"""data""": """/""".join(dict_path.split("""/"""       )[:-1]       )}       )
			lowerCamelCase       =      model[0].eval()

			# set weights for wav2vec2 encoder
			lowerCamelCase       =      WavaVecaModel(snake_case__       )
			lowerCamelCase       =      recursively_load_weights_wavaveca(model.encoder ,				snake_case__       )

			lowerCamelCase       =      SpeechaTextaForCausalLM(snake_case__       )
			lowerCamelCase   ,     lowerCamelCase       =      hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict() ,				strict=snake_case__       )

			# set output linear layer
			unexpected_keys.remove("""embed_out"""       )
			lowerCamelCase       =      nn.Parameter(model.decoder.embed_out.detach()       )

			# layer norm is init to identity matrix so leaving it is fine
			logger.warning(F'The following keys are missing when loading the decoder weights: {missing_keys}'       )
			logger.warning(F'The following keys are unexpected when loading the decoder weights: {unexpected_keys}'       )

			lowerCamelCase       =      SpeechEncoderDecoderModel(encoder=snake_case__ ,				decoder=snake_case__       )
			lowerCamelCase       =      False

			# add projection layer
			lowerCamelCase       =      nn.Parameter(projection_layer.weight       )
			lowerCamelCase       =      nn.Parameter(projection_layer.bias       )

			lowerCamelCase       =      create_vocab_dict(snake_case__       )

			with open(os.path.join(snake_case__ ,				"""vocab.json"""       ) ,				"""w"""       ) as fp:
						json.dump(snake_case__ ,				snake_case__       )

			lowerCamelCase       =      SpeechaTextaTokenizer(os.path.join(snake_case__ ,				"""vocab.json"""       )       )
			tokenizer.save_pretrained(snake_case__       )

			lowerCamelCase       =      hf_wavavec.config.to_dict()
			lowerCamelCase       =      tokenizer.pad_token_id
			lowerCamelCase       =      tokenizer.bos_token_id
			lowerCamelCase       =      tokenizer.eos_token_id
			lowerCamelCase       =      """speech_to_text_2"""
			lowerCamelCase       =      """wav2vec2"""

			lowerCamelCase       =      SpeechEncoderDecoderConfig.from_dict(snake_case__       )

			hf_wavavec.save_pretrained(snake_case__       )
			feature_extractor.save_pretrained(snake_case__       )


if __name__ == "__main__":
					lowerCAmelCase							:    Any  							=							argparse.ArgumentParser()
					parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
					parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""")
					parser.add_argument("""--dict_path""", default=None, type=str, help="""Path to dict of fine-tuned model""")
					parser.add_argument(
					    """--encoder_config_path""",
					    default="""facebook/wav2vec2-large-lv60""",
					    type=str,
					    help="""Path to hf encoder wav2vec2 checkpoint config""",
					)
					parser.add_argument(
					    """--decoder_config_path""",
					    default="""facebook/s2t-small-mustc-en-fr-st""",
					    type=str,
					    help="""Path to hf decoder s2t checkpoint config""",
					)
					parser.add_argument("""--vocab_size""", default=1_0224, type=int, help="""Vocab size of decoder""")
					parser.add_argument("""--num_decoder_layers""", default=7, type=int, help="""Number of decoder layers""")

					lowerCAmelCase							:    str  							=							parser.parse_args()
					convert_wavaveca_checkpoint(
					    args.checkpoint_path,
					    args.pytorch_dump_folder_path,
					    args.dict_path,
					    encoder_config_path=args.encoder_config_path,
					    decoder_config_path=args.decoder_config_path,
					    vocab_size=args.vocab_size,
					    num_decoder_layers=args.num_decoder_layers,
					)



