

'''simple docstring'''

import argparse

import torch
from torch import nn

from transformers import SpeechaTextConfig, SpeechaTextForConditionalGeneration




def 							_UpperCamelCase				(   lowerCAmelCase__:					List[Any]   )      -> Dict:
							SCREAMING_SNAKE_CASE_				=				[
							    'encoder.version',
							    'decoder.version',
							    'model.encoder.version',
							    'model.decoder.version',
							    'decoder.output_projection.weight',
							    '_float_tensor',
							    'encoder.embed_positions._float_tensor',
							    'decoder.embed_positions._float_tensor',
							]
							for k in ignore_keys:
														state_dict.pop(lowerCAmelCase__		,lowerCAmelCase__   )




def 							_UpperCamelCase				(   lowerCAmelCase__:					List[str]   )      -> List[str]:
							SCREAMING_SNAKE_CASE_				=				list(s_dict.keys()   )
							for key in keys:
														if "transformer_layers" in key:
																					SCREAMING_SNAKE_CASE_				=				s_dict.pop(lowerCAmelCase__   )
														elif "subsample" in key:
																					SCREAMING_SNAKE_CASE_				=				s_dict.pop(lowerCAmelCase__   )




def 							_UpperCamelCase				(   lowerCAmelCase__:					int   )      -> Dict:
							SCREAMING_SNAKE_CASE_				,    SCREAMING_SNAKE_CASE_				=				emb.weight.shape
							SCREAMING_SNAKE_CASE_				=				nn.Linear(lowerCAmelCase__		,lowerCAmelCase__		,bias=lowerCAmelCase__   )
							SCREAMING_SNAKE_CASE_				=				emb.weight.data
							return lin_layer




def 							_UpperCamelCase				(   lowerCAmelCase__:					str		,lowerCAmelCase__:					Optional[int]   )      -> Tuple:
							SCREAMING_SNAKE_CASE_				=				torch.load(lowerCAmelCase__		,map_location='cpu'   )
							SCREAMING_SNAKE_CASE_				=				mam_aaa['args']
							SCREAMING_SNAKE_CASE_				=				mam_aaa['model']
							SCREAMING_SNAKE_CASE_				=				state_dict['decoder.output_projection.weight']

							remove_ignore_keys_(lowerCAmelCase__   )
							rename_keys(lowerCAmelCase__   )

							SCREAMING_SNAKE_CASE_				=				state_dict['decoder.embed_tokens.weight'].shape[0]

							SCREAMING_SNAKE_CASE_				=				args.share_decoder_input_output_embed

							SCREAMING_SNAKE_CASE_				=				[int(lowerCAmelCase__   ) for i in args.conv_kernel_sizes.split(','   )]
							SCREAMING_SNAKE_CASE_				=				SpeechaTextConfig(
							    vocab_size=lowerCAmelCase__		,max_source_positions=args.max_source_positions		,max_target_positions=args.max_target_positions		,encoder_layers=args.encoder_layers		,decoder_layers=args.decoder_layers		,encoder_attention_heads=args.encoder_attention_heads		,decoder_attention_heads=args.decoder_attention_heads		,encoder_ffn_dim=args.encoder_ffn_embed_dim		,decoder_ffn_dim=args.decoder_ffn_embed_dim		,d_model=args.encoder_embed_dim		,dropout=args.dropout		,attention_dropout=args.attention_dropout		,activation_dropout=args.activation_dropout		,activation_function='relu'		,num_conv_layers=len(lowerCAmelCase__   )		,conv_channels=args.conv_channels		,conv_kernel_sizes=lowerCAmelCase__		,input_feat_per_channel=args.input_feat_per_channel		,input_channels=args.input_channels		,tie_word_embeddings=lowerCAmelCase__		,num_beams=5		,max_length=200		,use_cache=lowerCAmelCase__		,decoder_start_token_id=2		,early_stopping=lowerCAmelCase__		,)

							SCREAMING_SNAKE_CASE_				=				SpeechaTextForConditionalGeneration(lowerCAmelCase__   )
							SCREAMING_SNAKE_CASE_				,    SCREAMING_SNAKE_CASE_				=				model.model.load_state_dict(lowerCAmelCase__		,strict=lowerCAmelCase__   )
							if len(lowerCAmelCase__   ) > 0 and not set(lowerCAmelCase__   ) <= {
							    "encoder.embed_positions.weights",
							    "decoder.embed_positions.weights",
							}:
														raise ValueError(
														    'Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights`  are allowed to be missing,'
														    F""" but all the following weights are missing {missing}"""   )

							if tie_embeds:
														SCREAMING_SNAKE_CASE_				=				make_linear_from_emb(model.model.decoder.embed_tokens   )
							else:
														SCREAMING_SNAKE_CASE_				=				lm_head_weights

							model.save_pretrained(lowerCAmelCase__   )


if __name__ == "__main__":
							SCREAMING_SNAKE_CASE							:				Union[str, Any]     	=			argparse.ArgumentParser()
							# Required parameters
							parser.add_argument("--fairseq_path", type=str, help="Path to the fairseq model (.pt) file.")
							parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
							SCREAMING_SNAKE_CASE							:				List[str]     	=			parser.parse_args()
							convert_fairseq_sat_checkpoint_to_tfms(args.fairseq_path, args.pytorch_dump_folder_path)








'''simple docstring'''

import importlib.util
import json
import os
import warnings
from dataclasses import dataclass, field

import torch

from ..training_args import TrainingArguments
from ..utils import cached_property, is_sagemaker_dp_enabled, logging


SCREAMING_SNAKE_CASE							:				Optional[Any]     	=			logging.get_logger(__name__)




def 							_UpperCamelCase				(   )      -> List[Any]:
							# Get the sagemaker specific mp parameters from smp_options variable.
							SCREAMING_SNAKE_CASE_				=				os.getenv('SM_HP_MP_PARAMETERS'		,'{}'   )
							try:
														# Parse it and check the field "partitions" is included, it is required for model parallel.
														SCREAMING_SNAKE_CASE_				=				json.loads(lowerCAmelCase__   )
														if "partitions" not in smp_options:
																					return False
							except json.JSONDecodeError:
														return False

							# Get the sagemaker specific framework parameters from mpi_options variable.
							SCREAMING_SNAKE_CASE_				=				os.getenv('SM_FRAMEWORK_PARAMS'		,'{}'   )
							try:
														# Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
														SCREAMING_SNAKE_CASE_				=				json.loads(lowerCAmelCase__   )
														if not mpi_options.get('sagemaker_mpi_enabled'		,lowerCAmelCase__   ):
																					return False
							except json.JSONDecodeError:
														return False
							# Lastly, check if the `smdistributed` module is present.
							return importlib.util.find_spec('smdistributed'   ) is not None


if is_sagemaker_model_parallel_available():
							import smdistributed.modelparallel.torch as smp

							smp.init()






@dataclass
class    snake_case     (      lowercase_		):






				"""simple docstring"""
				_a    	=     field(
				    default="""""",						metadata={"""help""": """Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"""},						)



				def   a__					(    self       )     ->							Union[str, Any]:
											super().__post_init__()
											warnings.warn(
											    '`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use '
											    '`TrainingArguments` instead.',     _lowercase,     )



				@cached_property
				def   a__					(    self       )     ->							"torch.device":
											logger.info('PyTorch: setting up devices'       )
											if torch.distributed.is_available() and torch.distributed.is_initialized() and self.local_rank == -1:
																		logger.warning(
																		    'torch.distributed process group is initialized, but local_rank == -1. '
																		    'In order to use Torch DDP, launch your script with `python -m torch.distributed.launch'       )
											if self.no_cuda:
																		SCREAMING_SNAKE_CASE_				=				torch.device('cpu'       )
																		SCREAMING_SNAKE_CASE_				=				0
											elif is_sagemaker_model_parallel_available():
																		SCREAMING_SNAKE_CASE_				=				smp.local_rank()
																		SCREAMING_SNAKE_CASE_				=				torch.device('cuda',     _lowercase       )
																		SCREAMING_SNAKE_CASE_				=				1
											elif is_sagemaker_dp_enabled():
																		import smdistributed.dataparallel.torch.torch_smddp  # noqa: F401

																		torch.distributed.init_process_group(backend='smddp',     timeout=self.ddp_timeout_delta       )
																		SCREAMING_SNAKE_CASE_				=				int(os.getenv('SMDATAPARALLEL_LOCAL_RANK'       )       )
																		SCREAMING_SNAKE_CASE_				=				torch.device('cuda',     self.local_rank       )
																		SCREAMING_SNAKE_CASE_				=				1
											elif self.local_rank == -1:
																		# if n_gpu is > 1 we'll use nn.DataParallel.
																		# If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
																		# Explicitly set CUDA to the first (index 0) CUDA device, otherwise `set_device` will
																		# trigger an error that a device index is missing. Index 0 takes into account the
																		# GPUs available in the environment, so `CUDA_VISIBLE_DEVICES=1,2` with `cuda:0`
																		# will use the first GPU in that env, i.e. GPU#1
																		SCREAMING_SNAKE_CASE_				=				torch.device('cuda:0' if torch.cuda.is_available() else 'cpu'       )
																		# Sometimes the line in the postinit has not been run before we end up here, so just checking we're not at
																		# the default value.
																		SCREAMING_SNAKE_CASE_				=				torch.cuda.device_count()
											else:
																		# Here, we'll use torch.distributed.
																		# Initializes the distributed backend which will take care of synchronizing nodes/GPUs
																		if not torch.distributed.is_initialized():
																									torch.distributed.init_process_group(backend='nccl',     timeout=self.ddp_timeout_delta       )
																		SCREAMING_SNAKE_CASE_				=				torch.device('cuda',     self.local_rank       )
																		SCREAMING_SNAKE_CASE_				=				1

											if device.type == "cuda":
																		torch.cuda.set_device(_lowercase       )

											return device



				@property
				def   a__					(    self       )     ->							Optional[Any]:
											if is_sagemaker_model_parallel_available():
																		return smp.dp_size()

											return super().world_size



				@property
				def   a__					(    self       )     ->							Optional[Any]:
											return not is_sagemaker_model_parallel_available()





				@property
				def   a__					(    self       )     ->							Tuple:
											return False





