

"""simple docstring"""




import collections
import inspect
import unittest

from transformers import FocalNetConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch
				from torch import nn

				from transformers import (
				    FocalNetBackbone,
				    FocalNetForImageClassification,
				    FocalNetForMaskedImageModeling,
				    FocalNetModel,
				)
				from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
				from PIL import Image

				from transformers import AutoImageProcessor
class 			_UpperCAmelCase					:



	def __init__(   self			:    Optional[int]       ,  _lowercase			:    List[Any]       ,  _lowercase			:    Tuple=13       ,  _lowercase			:    Any=32       ,  _lowercase			:    str=2       ,  _lowercase			:    Any=3       ,  _lowercase			:    Tuple=16       ,  _lowercase			:    Optional[Any]=[32, 64, 1_28]       ,  _lowercase			:    Any=[1, 2, 1]       ,  _lowercase			:    Tuple=[2, 2, 4]       ,  _lowercase			:    List[Any]=2       ,  _lowercase			:    Any=2.0       ,  _lowercase			:    int=True       ,  _lowercase			:    Optional[Any]=0.0       ,  _lowercase			:    Optional[int]=0.0       ,  _lowercase			:    Dict=0.1       ,  _lowercase			:    int="gelu"       ,  _lowercase			:    Dict=False       ,  _lowercase			:    Tuple=True       ,  _lowercase			:    str=0.02       ,  _lowercase			:    Dict=1E-5       ,  _lowercase			:    Tuple=True       ,  _lowercase			:    Optional[Any]=None       ,  _lowercase			:    Optional[Any]=True       ,  _lowercase			:    Dict=10       ,  _lowercase			:    str=8       ,  _lowercase			:    Tuple=["stage1", "stage2"]       ,  _lowercase			:    str=[1, 2]       ,  ):
		__UpperCAmelCase							=      parent
		__UpperCAmelCase							=      batch_size
		__UpperCAmelCase							=      image_size
		__UpperCAmelCase							=      patch_size
		__UpperCAmelCase							=      num_channels
		__UpperCAmelCase							=      embed_dim
		__UpperCAmelCase							=      hidden_sizes
		__UpperCAmelCase							=      depths
		__UpperCAmelCase							=      num_heads
		__UpperCAmelCase							=      window_size
		__UpperCAmelCase							=      mlp_ratio
		__UpperCAmelCase							=      qkv_bias
		__UpperCAmelCase							=      hidden_dropout_prob
		__UpperCAmelCase							=      attention_probs_dropout_prob
		__UpperCAmelCase							=      drop_path_rate
		__UpperCAmelCase							=      hidden_act
		__UpperCAmelCase							=      use_absolute_embeddings
		__UpperCAmelCase							=      patch_norm
		__UpperCAmelCase							=      layer_norm_eps
		__UpperCAmelCase							=      initializer_range
		__UpperCAmelCase							=      is_training
		__UpperCAmelCase							=      scope
		__UpperCAmelCase							=      use_labels
		__UpperCAmelCase							=      type_sequence_label_size
		__UpperCAmelCase							=      encoder_stride
		__UpperCAmelCase							=      out_features
		__UpperCAmelCase							=      out_indices



	def     a   (   self			:    List[str]		):
		__UpperCAmelCase							=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

		__UpperCAmelCase							=      None
		if self.use_labels:
			__UpperCAmelCase							=      ids_tensor([self.batch_size]       ,  self.type_sequence_label_size		)

		__UpperCAmelCase							=      self.get_config()

		return config, pixel_values, labels



	def     a   (   self			:    Union[str, Any]		):
		return FocalNetConfig(
		    image_size=self.image_size       ,  patch_size=self.patch_size       ,  num_channels=self.num_channels       ,  embed_dim=self.embed_dim       ,  hidden_sizes=self.hidden_sizes       ,  depths=self.depths       ,  num_heads=self.num_heads       ,  window_size=self.window_size       ,  mlp_ratio=self.mlp_ratio       ,  qkv_bias=self.qkv_bias       ,  hidden_dropout_prob=self.hidden_dropout_prob       ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,  drop_path_rate=self.drop_path_rate       ,  hidden_act=self.hidden_act       ,  use_absolute_embeddings=self.use_absolute_embeddings       ,  path_norm=self.patch_norm       ,  layer_norm_eps=self.layer_norm_eps       ,  initializer_range=self.initializer_range       ,  encoder_stride=self.encoder_stride       ,  out_features=self.out_features       ,  out_indices=self.out_indices       ,  )



	def     a   (   self			:    Optional[Any]       ,  _lowercase			:    Union[str, Any]       ,  _lowercase			:    int       ,  _lowercase			:    Any		):
		__UpperCAmelCase							=      FocalNetModel(config=lowerCamelCase__		)
		model.to(lowerCamelCase__		)
		model.eval()
		__UpperCAmelCase							=      model(lowerCamelCase__		)

		__UpperCAmelCase							=      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths		) - 1))
		__UpperCAmelCase							=      int(config.embed_dim * 2 ** (len(config.depths		) - 1)		)

		self.parent.assertEqual(result.last_hidden_state.shape       ,  (self.batch_size, expected_seq_len, expected_dim)		)



	def     a   (   self			:    List[Any]       ,  _lowercase			:    Dict       ,  _lowercase			:    int       ,  _lowercase			:    Union[str, Any]		):
		__UpperCAmelCase							=      FocalNetBackbone(config=lowerCamelCase__		)
		model.to(lowerCamelCase__		)
		model.eval()
		__UpperCAmelCase							=      model(lowerCamelCase__		)

		# verify feature maps
		self.parent.assertEqual(len(result.feature_maps		)       ,  len(config.out_features		)		)
		self.parent.assertListEqual(list(result.feature_maps[0].shape		)       ,  [self.batch_size, self.image_size, 8, 8]		)

		# verify channels
		self.parent.assertEqual(len(model.channels		)       ,  len(config.out_features		)		)
		self.parent.assertListEqual(model.channels       ,  config.hidden_sizes[:-1]		)

		# verify backbone works with out_features=None
		__UpperCAmelCase							=      None
		__UpperCAmelCase							=      FocalNetBackbone(config=lowerCamelCase__		)
		model.to(lowerCamelCase__		)
		model.eval()
		__UpperCAmelCase							=      model(lowerCamelCase__		)

		# verify feature maps
		self.parent.assertEqual(len(result.feature_maps		)       ,  1		)
		self.parent.assertListEqual(list(result.feature_maps[0].shape		)       ,  [self.batch_size, self.image_size * 2, 4, 4]		)

		# verify channels
		self.parent.assertEqual(len(model.channels		)       ,  1		)
		self.parent.assertListEqual(model.channels       ,  [config.hidden_sizes[-1]]		)



	def     a   (   self			:    str       ,  _lowercase			:    int       ,  _lowercase			:    List[str]       ,  _lowercase			:    int		):
		__UpperCAmelCase							=      FocalNetForMaskedImageModeling(config=lowerCamelCase__		)
		model.to(lowerCamelCase__		)
		model.eval()
		__UpperCAmelCase							=      model(lowerCamelCase__		)
		self.parent.assertEqual(
		    result.reconstruction.shape       ,  (self.batch_size, self.num_channels, self.image_size, self.image_size)		)

		# test greyscale images
		__UpperCAmelCase							=      1
		__UpperCAmelCase							=      FocalNetForMaskedImageModeling(lowerCamelCase__		)
		model.to(lowerCamelCase__		)
		model.eval()

		__UpperCAmelCase							=      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]		)
		__UpperCAmelCase							=      model(lowerCamelCase__		)
		self.parent.assertEqual(result.reconstruction.shape       ,  (self.batch_size, 1, self.image_size, self.image_size)		)



	def     a   (   self			:    Dict       ,  _lowercase			:    List[str]       ,  _lowercase			:    Dict       ,  _lowercase			:    Tuple		):
		__UpperCAmelCase							=      self.type_sequence_label_size
		__UpperCAmelCase							=      FocalNetForImageClassification(lowerCamelCase__		)
		model.to(lowerCamelCase__		)
		model.eval()
		__UpperCAmelCase							=      model(lowerCamelCase__       ,  labels=lowerCamelCase__		)
		self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.type_sequence_label_size)		)

		# test greyscale images
		__UpperCAmelCase							=      1
		__UpperCAmelCase							=      FocalNetForImageClassification(lowerCamelCase__		)
		model.to(lowerCamelCase__		)
		model.eval()

		__UpperCAmelCase							=      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]		)
		__UpperCAmelCase							=      model(lowerCamelCase__		)
		self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.type_sequence_label_size)		)



	def     a   (   self			:    int		):
		__UpperCAmelCase							=      self.prepare_config_and_inputs()

		__UpperCAmelCase						,				__UpperCAmelCase						,				__UpperCAmelCase							=      config_and_inputs
		__UpperCAmelCase							=      {'''pixel_values''': pixel_values}
		return config, inputs_dict






@require_torch
class 			_UpperCAmelCase					(				_lowerCAmelCase						,  _lowerCAmelCase						,  unittest.TestCase    ):
	a__						:      List[str]						       = (
	    (
	        FocalNetModel,
	        FocalNetForImageClassification,
	        FocalNetForMaskedImageModeling,
	        FocalNetBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	a__						:      List[Any]						       = (
	    {"feature-extraction": FocalNetModel, "image-classification": FocalNetForImageClassification}
	    if is_torch_available()
	    else {}
	)
	a__						:      str						       = False

	a__						:      str						       = False
	a__						:      Optional[int]						       = False
	a__						:      Optional[int]						       = False
	a__						:      List[Any]						       = False



	def     a   (   self			:    Any		):
		__UpperCAmelCase							=      FocalNetModelTester(self		)
		__UpperCAmelCase							=      ConfigTester(self       ,  config_class=lowerCamelCase__       ,  embed_dim=37       ,  has_text_modality=lowerCamelCase__		)



	def     a   (   self			:    Optional[Any]		):
		self.create_and_test_config_common_properties()
		self.config_tester.create_and_test_config_to_json_string()
		self.config_tester.create_and_test_config_to_json_file()
		self.config_tester.create_and_test_config_from_and_save_pretrained()
		self.config_tester.create_and_test_config_with_num_labels()
		self.config_tester.check_config_can_be_init_without_params()
		self.config_tester.check_config_arguments_init()



	def     a   (   self			:    List[str]		):
		return



	def     a   (   self			:    str		):
		__UpperCAmelCase							=      self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*lowerCamelCase__		)



	def     a   (   self			:    Optional[int]		):
		__UpperCAmelCase							=      self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_backbone(*lowerCamelCase__		)



	def     a   (   self			:    Optional[int]		):
		__UpperCAmelCase							=      self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_masked_image_modeling(*lowerCamelCase__		)



	def     a   (   self			:    Optional[Any]		):
		__UpperCAmelCase							=      self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__		)



	@unittest.skip(reason='''FocalNet does not use inputs_embeds'''		)
	def     a   (   self			:    List[str]		):
		pass



	@unittest.skip(reason='''FocalNet does not use feedforward chunking'''		)
	def     a   (   self			:    Optional[int]		):
		pass



	def     a   (   self			:    str		):
		__UpperCAmelCase						,				__UpperCAmelCase							=      self.model_tester.prepare_config_and_inputs_for_common()

		for model_class in self.all_model_classes[:-1]:
			__UpperCAmelCase							=      model_class(lowerCamelCase__		)
			self.assertIsInstance(model.get_input_embeddings()       ,  (nn.Module)		)
			__UpperCAmelCase							=      model.get_output_embeddings()
			self.assertTrue(x is None or isinstance(lowerCamelCase__       ,  nn.Linear		)		)



	def     a   (   self			:    str		):
		__UpperCAmelCase						,				__UpperCAmelCase							=      self.model_tester.prepare_config_and_inputs_for_common()

		for model_class in self.all_model_classes[:-1]:
			__UpperCAmelCase							=      model_class(lowerCamelCase__		)
			__UpperCAmelCase							=      inspect.signature(model.forward		)
			# signature.parameters is an OrderedDict => so arg_names order is deterministic
			__UpperCAmelCase							=      [*signature.parameters.keys()]

			__UpperCAmelCase							=      ['''pixel_values''']
			self.assertListEqual(arg_names[:1]       ,  lowerCamelCase__		)



	def     a   (   self			:    Union[str, Any]       ,  _lowercase			:    List[str]       ,  _lowercase			:    str       ,  _lowercase			:    List[Any]       ,  _lowercase			:    Tuple		):
		__UpperCAmelCase							=      model_class(lowerCamelCase__		)
		model.to(lowerCamelCase__		)
		model.eval()

		with torch.no_grad():
			__UpperCAmelCase							=      model(**self._prepare_for_class(lowerCamelCase__       ,  lowerCamelCase__		)		)

		__UpperCAmelCase							=      outputs.hidden_states

		__UpperCAmelCase							=      getattr(
		    self.model_tester       ,  '''expected_num_hidden_layers'''       ,  len(self.model_tester.depths		) + 1		)
		self.assertEqual(len(lowerCamelCase__		)       ,  lowerCamelCase__		)

		# FocalNet has a different seq_length
		__UpperCAmelCase							=      (
		    config.patch_size
		    if isinstance(config.patch_size       ,  collections.abc.Iterable		)
		    else (config.patch_size, config.patch_size)
		)

		__UpperCAmelCase							=      (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

		self.assertListEqual(
		    list(hidden_states[0].shape[-2:]		)       ,  [num_patches, self.model_tester.embed_dim]       ,  )

		__UpperCAmelCase							=      outputs.reshaped_hidden_states
		self.assertEqual(len(lowerCamelCase__		)       ,  lowerCamelCase__		)

		__UpperCAmelCase						,				__UpperCAmelCase						,				__UpperCAmelCase						,				__UpperCAmelCase							=      reshaped_hidden_states[0].shape
		__UpperCAmelCase							=      (
		    reshaped_hidden_states[0].view(lowerCamelCase__       ,  lowerCamelCase__       ,  height * width		).permute(0       ,  2       ,  1		)
		)
		self.assertListEqual(
		    list(reshaped_hidden_states.shape[-2:]		)       ,  [num_patches, self.model_tester.embed_dim]       ,  )



	def     a   (   self			:    str		):
		__UpperCAmelCase						,				__UpperCAmelCase							=      self.model_tester.prepare_config_and_inputs_for_common()

		__UpperCAmelCase							=      (
		    self.model_tester.image_size
		    if isinstance(self.model_tester.image_size       ,  collections.abc.Iterable		)
		    else (self.model_tester.image_size, self.model_tester.image_size)
		)

		for model_class in self.all_model_classes[:-1]:
			__UpperCAmelCase							=      True
			self.check_hidden_states_output(lowerCamelCase__       ,  lowerCamelCase__       ,  lowerCamelCase__       ,  lowerCamelCase__		)

			# check that output_hidden_states also work using config
			del inputs_dict["output_hidden_states"]
			__UpperCAmelCase							=      True

			self.check_hidden_states_output(lowerCamelCase__       ,  lowerCamelCase__       ,  lowerCamelCase__       ,  lowerCamelCase__		)



	def     a   (   self			:    str		):
		__UpperCAmelCase						,				__UpperCAmelCase							=      self.model_tester.prepare_config_and_inputs_for_common()
		__UpperCAmelCase							=      3

		__UpperCAmelCase							=      (
		    self.model_tester.image_size
		    if isinstance(self.model_tester.image_size       ,  collections.abc.Iterable		)
		    else (self.model_tester.image_size, self.model_tester.image_size)
		)
		__UpperCAmelCase							=      (
		    config.patch_size
		    if isinstance(config.patch_size       ,  collections.abc.Iterable		)
		    else (config.patch_size, config.patch_size)
		)

		__UpperCAmelCase							=      image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
		__UpperCAmelCase							=      image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

		for model_class in self.all_model_classes[:-1]:
			__UpperCAmelCase							=      True
			self.check_hidden_states_output(lowerCamelCase__       ,  lowerCamelCase__       ,  lowerCamelCase__       ,  (padded_height, padded_width)		)

			# check that output_hidden_states also work using config
			del inputs_dict["output_hidden_states"]
			__UpperCAmelCase							=      True
			self.check_hidden_states_output(lowerCamelCase__       ,  lowerCamelCase__       ,  lowerCamelCase__       ,  (padded_height, padded_width)		)



	@slow
	def     a   (   self			:    Union[str, Any]		):
		for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			__UpperCAmelCase							=      FocalNetModel.from_pretrained(lowerCamelCase__		)
			self.assertIsNotNone(lowerCamelCase__		)



	def     a   (   self			:    Any		):
		__UpperCAmelCase						,				__UpperCAmelCase							=      self.model_tester.prepare_config_and_inputs_for_common()

		__UpperCAmelCase							=      _config_zero_init(lowerCamelCase__		)
		for model_class in self.all_model_classes:
			__UpperCAmelCase							=      model_class(config=lowerCamelCase__		)
			for name, param in model.named_parameters():
				if "embeddings" not in name and param.requires_grad:
					self.assertIn(
					    ((param.data.mean() * 1E9).round() / 1E9).item()       ,  [0.0, 1.0]       ,  msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''       ,  )






@require_vision
@require_torch
class 			_UpperCAmelCase					(				unittest.TestCase    ):



	@cached_property
	def     a   (   self			:    Any		):
		return AutoImageProcessor.from_pretrained('''microsoft/focalnet-tiny'''		) if is_vision_available() else None



	@slow
	def     a   (   self			:    Optional[Any]		):
		__UpperCAmelCase							=      FocalNetForImageClassification.from_pretrained('''microsoft/focalnet-tiny'''		).to(lowerCamelCase__		)
		__UpperCAmelCase							=      self.default_image_processor

		__UpperCAmelCase							=      Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
		__UpperCAmelCase							=      image_processor(images=lowerCamelCase__       ,  return_tensors='''pt'''		).to(lowerCamelCase__		)

		# forward pass
		with torch.no_grad():
			__UpperCAmelCase							=      model(**lowerCamelCase__		)

		# verify the logits
		__UpperCAmelCase							=      torch.Size((1, 10_00)		)
		self.assertEqual(outputs.logits.shape       ,  lowerCamelCase__		)
		__UpperCAmelCase							=      torch.tensor([0.2_166, -0.4_368, 0.2_191]		).to(lowerCamelCase__		)
		self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,  lowerCamelCase__       ,  atol=1E-4		)		)
		self.assertTrue(outputs.logits.argmax(dim=-1		).item()       ,  2_81		)






@require_torch
class 			_UpperCAmelCase					(				_lowerCAmelCase						,  unittest.TestCase    ):
	a__						:      Dict						       = (FocalNetBackbone,) if is_torch_available() else ()
	a__						:      Dict						       = FocalNetConfig

	a__						:      Tuple						       = False



	def     a   (   self			:    Tuple		):
		__UpperCAmelCase							=      FocalNetModelTester(self		)






import argparse

import fairseq
import torch
from torch import nn

from transformers import (
    MBartaaTokenizer,
    MBartConfig,
    MBartForCausalLM,
    SpeechEncoderDecoderConfig,
    SpeechEncoderDecoderModel,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaModel,
    logging,
)


logging.set_verbosity_info()
__A        =    logging.get_logger(__name__)

__A        =    {
    "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",
}
__A        =    [
    "lm_head",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
]







def 			lowerCamelCase_		(       UpperCamelCase__				:      Any ,     UpperCamelCase__				:      Any ,     UpperCamelCase__				:      Optional[Any] ,     UpperCamelCase__				:      Union[str, Any] ,     UpperCamelCase__				:      Optional[int]      )     ->       Tuple:





				"""simple docstring"""


				for attribute in key.split('.'      ):
								__lowerCamelCase		       =    getattr(UpperCamelCase__ ,     UpperCamelCase__      )

				if weight_type is not None:
								__lowerCamelCase		       =    getattr(UpperCamelCase__ ,     UpperCamelCase__      ).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 			lowerCamelCase_		(       UpperCamelCase__				:      Optional[Any] ,     UpperCamelCase__				:      Tuple      )     ->       Optional[Any]:





				"""simple docstring"""


				__lowerCamelCase		       =    []
				__lowerCamelCase		       =    fairseq_model.state_dict()

				__lowerCamelCase		       =    hf_model.feature_extractor
				__lowerCamelCase		       =    hf_model.adapter

				for name, value in fairseq_dict.items():
								__lowerCamelCase		       =    False
								if "conv_layers" in name:
												load_conv_layer(
												    UpperCamelCase__ ,     UpperCamelCase__ ,     UpperCamelCase__ ,     UpperCamelCase__ ,     hf_model.config.feat_extract_norm == 'group' ,     )
												__lowerCamelCase		       =    True
								elif any(x in name for x in ['adaptor', 'w2v_encoder.proj.', 'w2v_proj_ln.']      ):
												load_adapter(UpperCamelCase__ ,     UpperCamelCase__ ,     UpperCamelCase__ ,     UpperCamelCase__      )
												__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(UpperCamelCase__      )[0].split('.'      )[-2]
																								__lowerCamelCase		       =    mapped_key.replace('*' ,     UpperCamelCase__      )
																				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(UpperCamelCase__ ,     UpperCamelCase__ ,     UpperCamelCase__ ,     UpperCamelCase__ ,     UpperCamelCase__      )
																continue
								if not is_used:
												unused_weights.append(UpperCamelCase__      )

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







def 			lowerCamelCase_		(       UpperCamelCase__				:      Dict ,     UpperCamelCase__				:      Any ,     UpperCamelCase__				:      str ,     UpperCamelCase__				:      Tuple ,     UpperCamelCase__				:      Tuple      )     ->       int:





				"""simple docstring"""


				__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(UpperCamelCase__      )







def 			lowerCamelCase_		(       UpperCamelCase__				:      Tuple ,     UpperCamelCase__				:      Optional[Any] ,     UpperCamelCase__				:      Any ,     UpperCamelCase__				:      int      )     ->       Union[str, Any]:





				"""simple docstring"""


				__lowerCamelCase		       =    full_name.split('adaptor.'      )[-1]
				__lowerCamelCase		       =    name.split('.'      )

				if items[1].isdigit():
								__lowerCamelCase		       =    int(items[1]      )
				else:
								__lowerCamelCase		       =    None

				if "adaptor" not in full_name:
								if "proj_ln" in full_name:
												# has to be layer norm
												if "bias" in name:
																assert (
																    value.shape == adapter.proj_layer_norm.bias.data.shape
																), F"""{full_name} has size {value.shape}, but {adapter.proj_layer_norm.bias.data.shape} was found."""
																__lowerCamelCase		       =    value
																logger.info(F"""Adapter proj layer norm bias was initialized from {full_name}."""      )
												if "weight" in name:
																assert (
																    value.shape == adapter.proj_layer_norm.weight.data.shape
																), F"""{full_name} has size {value.shape}, but {adapter.proj_layer_norm.weight.data.shape} was found."""
																__lowerCamelCase		       =    value
								else:
												# has to be projection layer
												if "bias" in name:
																assert (
																    value.shape == adapter.proj.bias.data.shape
																), F"""{full_name} has size {value.shape}, but {adapter.proj.bias.data.shape} was found."""
																__lowerCamelCase		       =    value
																logger.info(F"""Adapter proj layer bias was initialized from {full_name}."""      )
												if "weight" in name:
																assert (
																    value.shape == adapter.proj.weight.data.shape
																), F"""{full_name} has size {value.shape}, but {adapter.proj.weight.data.shape} was found."""
																__lowerCamelCase		       =    value
																logger.info(F"""Adapter proj layer weight was initialized from {full_name}."""      )
				elif isinstance(UpperCamelCase__ ,     UpperCamelCase__      ):
								if "bias" in name:
												assert (
												    value.shape == adapter.layers[layer_id].conv.bias.data.shape
												), F"""{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.bias.data.shape} was found."""
												__lowerCamelCase		       =    value
												logger.info(F"""Adapter layer {layer_id} bias was initialized from {full_name}."""      )
								elif "weight" in name:
												assert (
												    value.shape == adapter.layers[layer_id].conv.weight.data.shape
												), F"""{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.weight.data.shape} was found."""
												__lowerCamelCase		       =    value
												logger.info(F"""Adapter layer {layer_id} bias was initialized from {full_name}."""      )
				else:
								unused_weights.append(UpperCamelCase__      )







def 			lowerCamelCase_		(       UpperCamelCase__				:      Tuple      )     ->       Tuple:





				"""simple docstring"""


				__lowerCamelCase       ,						__lowerCamelCase		       =    emb.weight.shape
				__lowerCamelCase		       =    nn.Linear(UpperCamelCase__ ,     UpperCamelCase__ ,     bias=UpperCamelCase__      )
				__lowerCamelCase		       =    emb.weight.data
				return lin_layer







@torch.no_grad()
def 			lowerCamelCase_		(       UpperCamelCase__				:      List[str] ,     UpperCamelCase__				:      List[Any] ,     UpperCamelCase__				:      Union[str, Any] ,     UpperCamelCase__				:      Dict ,     UpperCamelCase__				:      List[str] ,     UpperCamelCase__				:      Union[str, Any] ,     UpperCamelCase__				:      Optional[int] ,     UpperCamelCase__				:      Union[str, Any] ,     UpperCamelCase__				:      Optional[Any] ,     UpperCamelCase__				:      str ,     UpperCamelCase__				:      Optional[Any] ,     )     ->       str:





				"""simple docstring"""


				__lowerCamelCase		       =    WavaVecaConfig.from_pretrained(
				    UpperCamelCase__ ,     add_adapter=UpperCamelCase__ ,     adapter_stride=UpperCamelCase__ ,     adapter_kernel_size=UpperCamelCase__ ,     use_auth_token=UpperCamelCase__ ,     output_hidden_size=UpperCamelCase__ ,     )
				__lowerCamelCase		       =    MBartConfig.from_pretrained(UpperCamelCase__      )

				# load model
				__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase		       =    fairseq.checkpoint_utils.load_model_ensemble_and_task(
				    [checkpoint_path] ,     arg_overrides={
				        'config_yaml': config_yaml_path,
				        'data': '/'.join(dict_path.split('/'      )[:-1]      ),
				        'w2v_path': checkpoint_path,
				        'load_pretrained_decoder_from': None,
				    } ,     )
				__lowerCamelCase		       =    model[0].eval()

				# load feature extractor
				__lowerCamelCase		       =    WavaVecaFeatureExtractor.from_pretrained(UpperCamelCase__ ,     use_auth_token=UpperCamelCase__      )

				# set weights for wav2vec2 encoder
				__lowerCamelCase		       =    WavaVecaModel(UpperCamelCase__      )

				recursively_load_weights_wavaveca(model.encoder ,     UpperCamelCase__      )

				# load decoder weights
				__lowerCamelCase		       =    MBartForCausalLM(UpperCamelCase__      )
				__lowerCamelCase       ,						__lowerCamelCase		       =    hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict() ,     strict=UpperCamelCase__      )
				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=UpperCamelCase__ ,     decoder=UpperCamelCase__      )
				__lowerCamelCase		       =    False

				__lowerCamelCase		       =    MBartaaTokenizer(UpperCamelCase__      )
				tokenizer.save_pretrained(UpperCamelCase__      )

				__lowerCamelCase		       =    hf_wavavec.config.to_dict()
				__lowerCamelCase		       =    tokenizer.pad_token_id
				__lowerCamelCase		       =    tokenizer.bos_token_id
				__lowerCamelCase		       =    tokenizer.eos_token_id
				__lowerCamelCase		       =    'mbart50'
				__lowerCamelCase		       =    'wav2vec2'

				__lowerCamelCase		       =    tokenizer.eos_token_id
				__lowerCamelCase		       =    25_0004
				__lowerCamelCase		       =    tokenizer.eos_token_id

				__lowerCamelCase		       =    SpeechEncoderDecoderConfig.from_dict(UpperCamelCase__      )

				hf_wavavec.save_pretrained(UpperCamelCase__      )
				feature_extractor.save_pretrained(UpperCamelCase__      )


if __name__ == "__main__":
					__A        =    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("--config_yaml_path", default=None, type=str, help="Path to yaml file of fine-tuned model")
					parser.add_argument(
					    "--encoder_config_path",
					    default="facebook/wav2vec2-xls-r-1b",
					    type=str,
					    help="Path to hf encoder wav2vec2 checkpoint config",
					)
					parser.add_argument(
					    "--decoder_config_path",
					    default="facebook/mbart-large-50-one-to-many-mmt",
					    type=str,
					    help="Path to hf decoder checkpoint config",
					)
					parser.add_argument("--add_adapter", default=True, type=bool, help="whethere to add model adapter layers")
					parser.add_argument("--adapter_stride", default=2, type=int, help="stride of adapter layers")
					parser.add_argument("--adapter_kernel_size", default=3, type=int, help="kernel size of adapter layers")
					parser.add_argument("--encoder_output_dim", default=10_24, type=int, help="encoder output dim")
					parser.add_argument("--start_token_id", default=25_00_04, type=int, help="`decoder_start_token_id` of model config")

					__A        =    parser.parse_args()
					convert_wavaveca_checkpoint(
					    args.checkpoint_path,
					    args.pytorch_dump_folder_path,
					    args.dict_path,
					    args.config_yaml_path,
					    encoder_config_path=args.encoder_config_path,
					    decoder_config_path=args.decoder_config_path,
					    add_adapter=args.add_adapter,
					    adapter_kernel_size=args.adapter_kernel_size,
					    adapter_stride=args.adapter_stride,
					    decoder_start_token_id=args.start_token_id,
					    encoder_output_dim=args.encoder_output_dim,
					)


