


"""simple docstring"""
import argparse

import torch
from torch import nn

from transformers import SpeechaTextConfig, SpeechaTextForConditionalGeneration







def 						_a				(      _SCREAMING_SNAKE_CASE				)    ->				Tuple:
							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(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)







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







def 						_a				(      _SCREAMING_SNAKE_CASE				)    ->				Optional[Any]:
							snake_case_       ,						snake_case_           =		emb.weight.shape
							snake_case_           =		nn.Linear(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, bias=_SCREAMING_SNAKE_CASE				)
							snake_case_           =		emb.weight.data
							return lin_layer







def 						_a				(      _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)    ->				str:
							snake_case_           =		torch.load(_SCREAMING_SNAKE_CASE				, map_location="""cpu"""				)
							snake_case_           =		mam_aaa["""args"""]
							snake_case_           =		mam_aaa["""model"""]
							snake_case_           =		state_dict["""decoder.output_projection.weight"""]

							remove_ignore_keys_(_SCREAMING_SNAKE_CASE				)
							rename_keys(_SCREAMING_SNAKE_CASE				)

							snake_case_           =		state_dict["""decoder.embed_tokens.weight"""].shape[0]

							snake_case_           =		args.share_decoder_input_output_embed

							snake_case_           =		[int(_SCREAMING_SNAKE_CASE				) for i in args.conv_kernel_sizes.split(""","""				)]
							snake_case_           =		SpeechaTextConfig(
							    vocab_size=_SCREAMING_SNAKE_CASE				, 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(_SCREAMING_SNAKE_CASE				)				, conv_channels=args.conv_channels				, conv_kernel_sizes=_SCREAMING_SNAKE_CASE				, input_feat_per_channel=args.input_feat_per_channel				, input_channels=args.input_channels				, tie_word_embeddings=_SCREAMING_SNAKE_CASE				, num_beams=5				, max_length=200				, use_cache=_SCREAMING_SNAKE_CASE				, decoder_start_token_id=2				, early_stopping=_SCREAMING_SNAKE_CASE				, )

							snake_case_           =		SpeechaTextForConditionalGeneration(_SCREAMING_SNAKE_CASE				)
							snake_case_       ,						snake_case_           =		model.model.load_state_dict(_SCREAMING_SNAKE_CASE				, strict=_SCREAMING_SNAKE_CASE				)
							if len(_SCREAMING_SNAKE_CASE				) > 0 and not set(_SCREAMING_SNAKE_CASE				) <= {
							    "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:
														snake_case_           =		make_linear_from_emb(model.model.decoder.embed_tokens				)
							else:
														snake_case_           =		lm_head_weights

							model.save_pretrained(_SCREAMING_SNAKE_CASE				)


if __name__ == "__main__":
				__SCREAMING_SNAKE_CASE							:    int		=    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							:    str		=    parser.parse_args()
				convert_fairseq_sat_checkpoint_to_tfms(args.fairseq_path, args.pytorch_dump_folder_path)







"""simple docstring"""
from __future__ import annotations







def 						_a				(      _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)    ->				list[int]:
							snake_case_           =		0
							snake_case_           =		len(_SCREAMING_SNAKE_CASE				) - 1

							while i < j:
														if nums[i] + nums[j] == target:
																					return [i, j]
														elif nums[i] + nums[j] < target:
																					snake_case_           =		i + 1
														else:
																					snake_case_           =		j - 1

							return []


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				print(f"""{two_pointer([2, 7, 11, 15], 9) = }""")



