




'''simple docstring'''


import argparse
from pathlib import Path

import fairseq
import torch
from fairseq.models.xmod import XMODModel as FairseqXmodModel
from packaging import version

from transformers import XmodConfig, XmodForMaskedLM, XmodForSequenceClassification
from transformers.utils import logging


if version.parse(fairseq.__version__) < version.parse('0.12.2'):
				raise Exception('requires fairseq >= 0.12.2')
if version.parse(fairseq.__version__) > version.parse('2'):
				raise Exception('requires fairseq < v2')

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

_snake_case : int  				=						'Hello, World!'
_snake_case : str  				=						'en_XX'
def 						snake_case_       (UpperCamelCase			:    List[Any]					,		UpperCamelCase			:    Dict					,		UpperCamelCase			:    List[Any] ):





							'''simple docstring'''


							_a      	=							Path('''data_bin''' )
							_a      	=							FairseqXmodModel.from_pretrained(
							    model_name_or_path=str(Path(__snake_case ).parent )					,		checkpoint_file=Path(__snake_case ).name					,		_name='''xmod_base'''					,		arch='''xmod_base'''					,		task='''multilingual_masked_lm'''					,		data_name_or_path=str(__snake_case )					,		bpe='''sentencepiece'''					,		sentencepiece_model=str(Path(__snake_case ).parent / '''sentencepiece.bpe.model''' )					,		src_dict=str(data_dir / '''dict.txt''' )					,		)
							xmod.eval()  # disable dropout
							print(__snake_case )

							_a      	=							xmod.model.encoder.sentence_encoder
							_a      	=							XmodConfig(
							    vocab_size=xmod_sent_encoder.embed_tokens.num_embeddings					,		hidden_size=xmod.cfg.model.encoder_embed_dim					,		num_hidden_layers=xmod.cfg.model.encoder_layers					,		num_attention_heads=xmod.cfg.model.encoder_attention_heads					,		intermediate_size=xmod.cfg.model.encoder_ffn_embed_dim					,		max_position_embeddings=514					,		type_vocab_size=1					,		layer_norm_eps=1e-5					,		pre_norm=xmod.cfg.model.encoder_normalize_before					,		adapter_reduction_factor=getattr(xmod.cfg.model					,		'''bottleneck'''					,		2 )					,		adapter_layer_norm=xmod.cfg.model.adapter_layer_norm					,		adapter_reuse_layer_norm=xmod.cfg.model.adapter_reuse_layer_norm					,		ln_before_adapter=xmod.cfg.model.ln_before_adapter					,		languages=xmod.cfg.model.languages					,		)
							if classification_head:
														_a      	=							xmod.model.classification_heads['''mnli'''].out_proj.weight.shape[0]

							print('''Our X-MOD config:'''					,		__snake_case )

							_a      	=							XmodForSequenceClassification(__snake_case ) if classification_head else XmodForMaskedLM(__snake_case )
							model.eval()

							# Now let's copy all the weights.
							# Embeddings
							_a      	=							xmod_sent_encoder.embed_tokens.weight
							_a      	=							xmod_sent_encoder.embed_positions.weight
							_a      	=							torch.zeros_like(
							    model.roberta.embeddings.token_type_embeddings.weight )  # just zero them out b/c xmod doesn't use them.

							_a      	=							xmod_sent_encoder.layernorm_embedding.weight
							_a      	=							xmod_sent_encoder.layernorm_embedding.bias

							for i in range(config.num_hidden_layers ):
														# Encoder: start of layer
														_a      	=							model.roberta.encoder.layer[i]
														_a      	=							xmod_sent_encoder.layers[i]

														# self attention
														_a      	=							layer.attention.self
														if not (
														    xmod_layer.self_attn.k_proj.weight.data.shape
														    == xmod_layer.self_attn.q_proj.weight.data.shape
														    == xmod_layer.self_attn.v_proj.weight.data.shape
														    == torch.Size((config.hidden_size, config.hidden_size) )
														):
																					raise AssertionError('''Dimensions of self-attention weights do not match.''' )

														_a      	=							xmod_layer.self_attn.q_proj.weight
														_a      	=							xmod_layer.self_attn.q_proj.bias
														_a      	=							xmod_layer.self_attn.k_proj.weight
														_a      	=							xmod_layer.self_attn.k_proj.bias
														_a      	=							xmod_layer.self_attn.v_proj.weight
														_a      	=							xmod_layer.self_attn.v_proj.bias

														# self-attention output
														_a      	=							layer.attention.output
														if self_output.dense.weight.shape != xmod_layer.self_attn.out_proj.weight.shape:
																					raise AssertionError('''Dimensions of self-attention output weights do not match.''' )
														_a      	=							xmod_layer.self_attn.out_proj.weight
														_a      	=							xmod_layer.self_attn.out_proj.bias
														_a      	=							xmod_layer.self_attn_layer_norm.weight
														_a      	=							xmod_layer.self_attn_layer_norm.bias

														# intermediate
														_a      	=							layer.intermediate
														if intermediate.dense.weight.shape != xmod_layer.fca.weight.shape:
																					raise AssertionError('''Dimensions of intermediate weights do not match.''' )
														_a      	=							xmod_layer.fca.weight
														_a      	=							xmod_layer.fca.bias

														# output
														_a      	=							layer.output
														if bert_output.dense.weight.shape != xmod_layer.fca.weight.shape:
																					raise AssertionError('''Dimensions of feed-forward weights do not match.''' )
														_a      	=							xmod_layer.fca.weight
														_a      	=							xmod_layer.fca.bias
														_a      	=							xmod_layer.final_layer_norm.weight
														_a      	=							xmod_layer.final_layer_norm.bias
														if bert_output.adapter_layer_norm is not None:
																					_a      	=							xmod_layer.adapter_layer_norm.weight
																					_a      	=							xmod_layer.adapter_layer_norm.bias

														if sorted(bert_output.adapter_modules.keys() ) != sorted(xmod_layer.adapter_modules.keys() ):
																					raise AssertionError('''Lists of language adapters do not match.''' )
														for lang_code, adapter in xmod_layer.adapter_modules.items():
																					_a      	=							bert_output.adapter_modules[lang_code]
																					_a      	=							xmod_layer.adapter_modules[lang_code]
																					_a      	=							from_adapter.fca.weight
																					_a      	=							from_adapter.fca.bias
																					_a      	=							from_adapter.fca.weight
																					_a      	=							from_adapter.fca.bias

														# end of layer

							if xmod_sent_encoder.layer_norm is not None:
														_a      	=							xmod_sent_encoder.layer_norm.weight
														_a      	=							xmod_sent_encoder.layer_norm.bias

							if classification_head:
														_a      	=							xmod.model.classification_heads['''mnli'''].dense.weight
														_a      	=							xmod.model.classification_heads['''mnli'''].dense.bias
														_a      	=							xmod.model.classification_heads['''mnli'''].out_proj.weight
														_a      	=							xmod.model.classification_heads['''mnli'''].out_proj.bias
							else:
														# LM Head
														_a      	=							xmod.model.encoder.lm_head.dense.weight
														_a      	=							xmod.model.encoder.lm_head.dense.bias
														_a      	=							xmod.model.encoder.lm_head.layer_norm.weight
														_a      	=							xmod.model.encoder.lm_head.layer_norm.bias
														_a      	=							xmod.model.encoder.lm_head.weight
														_a      	=							xmod.model.encoder.lm_head.bias

							# Let's check that we get the same results.
							_a      	=							xmod.encode(__snake_case ).unsqueeze(0 )  # batch of size 1
							model.roberta.set_default_language(__snake_case )

							_a      	=							model(__snake_case )[0]
							if classification_head:
														_a      	=							xmod.model.classification_heads['''mnli'''](xmod.extract_features(__snake_case ) )
							else:
														_a      	=							xmod.model(__snake_case					,		lang_id=[SAMPLE_LANGUAGE] )[0]
							print(our_output.shape					,		their_output.shape )
							_a      	=							torch.max(torch.abs(our_output - their_output ) ).item()
							print(f'max_absolute_diff = {max_absolute_diff}' )  # ~ 1e-7
							_a      	=							torch.allclose(__snake_case					,		__snake_case					,		atol=1e-3 )
							print('''Do both models output the same tensors?'''					,		'''🔥''' if success else '''💩''' )
							if not success:
														raise Exception('''Something went wRoNg''' )

							Path(__snake_case ).mkdir(parents=__snake_case					,		exist_ok=__snake_case )
							print(f'Saving model to {pytorch_dump_folder_path}' )
							model.save_pretrained(__snake_case )


if __name__ == "__main__":
				_snake_case : int  				=						argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '--xmod_checkpoint_path', default=None, type=str, required=True, help='Path the official PyTorch dump.'
				)
				parser.add_argument(
				    '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
				)
				parser.add_argument(
				    '--classification_head', action='store_true', help='Whether to convert a final classification head.'
				)
				_snake_case : Optional[Any]  				=						parser.parse_args()
				convert_xmod_checkpoint_to_pytorch(
				    args.xmod_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
				)



"""simple docstring"""





from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching



def  lowerCamelCase__						(     )				->						List[str]:


					"""simple docstring"""





					import os as original_os
					from os import path as original_path
					from os import rename as original_rename
					from os.path import dirname as original_dirname
					from os.path import join as original_join

					assert _test_patching.os is original_os
					assert _test_patching.path is original_path
					assert _test_patching.join is original_join

					assert _test_patching.renamed_os is original_os
					assert _test_patching.renamed_path is original_path
					assert _test_patching.renamed_join is original_join

					_UpperCamelCase									=    '''__test_patch_submodule_mock__'''
					with patch_submodule(_test_patching,	'''os.path.join''',	__snake_case      ):
										# Every way to access os.path.join must be patched, and the rest must stay untouched

										# check os.path.join
										assert isinstance(_test_patching.os,	_PatchedModuleObj      )
										assert isinstance(_test_patching.os.path,	_PatchedModuleObj      )
										assert _test_patching.os.path.join is mock

										# check path.join
										assert isinstance(_test_patching.path,	_PatchedModuleObj      )
										assert _test_patching.path.join is mock

										# check join
										assert _test_patching.join is mock

										# check that the other attributes are untouched
										assert _test_patching.os.rename is original_rename
										assert _test_patching.path.dirname is original_dirname
										assert _test_patching.os.path.dirname is original_dirname

										# Even renamed modules or objects must be patched

										# check renamed_os.path.join
										assert isinstance(_test_patching.renamed_os,	_PatchedModuleObj      )
										assert isinstance(_test_patching.renamed_os.path,	_PatchedModuleObj      )
										assert _test_patching.renamed_os.path.join is mock

										# check renamed_path.join
										assert isinstance(_test_patching.renamed_path,	_PatchedModuleObj      )
										assert _test_patching.renamed_path.join is mock

										# check renamed_join
										assert _test_patching.renamed_join is mock

										# check that the other attributes are untouched
										assert _test_patching.renamed_os.rename is original_rename
										assert _test_patching.renamed_path.dirname is original_dirname
										assert _test_patching.renamed_os.path.dirname is original_dirname

					# check that everthing is back to normal when the patch is over

					assert _test_patching.os is original_os
					assert _test_patching.path is original_path
					assert _test_patching.join is original_join

					assert _test_patching.renamed_os is original_os
					assert _test_patching.renamed_path is original_path
					assert _test_patching.renamed_join is original_join



def  lowerCamelCase__						(     )				->						List[str]:


					"""simple docstring"""





					assert _test_patching.open is open

					_UpperCamelCase									=    '''__test_patch_submodule_builtin_mock__'''
					# _test_patching has "open" in its globals
					assert _test_patching.open is open
					with patch_submodule(_test_patching,	'''open''',	__snake_case      ):
										assert _test_patching.open is mock

					# check that everthing is back to normal when the patch is over

					assert _test_patching.open is open



def  lowerCamelCase__						(     )				->						Union[str, Any]:


					"""simple docstring"""





					_UpperCamelCase									=    '''__test_patch_submodule_missing_mock__'''
					with patch_submodule(_test_patching,	'''pandas.read_csv''',	__snake_case      ):
										pass



def  lowerCamelCase__						(     )				->						Dict:


					"""simple docstring"""





					_UpperCamelCase									=    '''__test_patch_submodule_missing_builtin_mock__'''
					# _test_patching doesn't have "len" in its globals
					assert getattr(_test_patching,	'''len''',	__snake_case      ) is None
					with patch_submodule(_test_patching,	'''len''',	__snake_case      ):
										assert _test_patching.len is mock
					assert _test_patching.len is len



def  lowerCamelCase__						(     )				->						Tuple:


					"""simple docstring"""





					_UpperCamelCase									=    '''__test_patch_submodule_start_and_stop_mock__'''
					_UpperCamelCase									=    patch_submodule(_test_patching,	'''open''',	__snake_case      )
					assert _test_patching.open is open
					patch.start()
					assert _test_patching.open is mock
					patch.stop()
					assert _test_patching.open is open



def  lowerCamelCase__						(     )				->						Optional[int]:


					"""simple docstring"""





					from os import rename as original_rename
					from os.path import dirname as original_dirname
					from os.path import join as original_join

					_UpperCamelCase									=    '''__test_patch_submodule_successive_join__'''
					_UpperCamelCase									=    '''__test_patch_submodule_successive_dirname__'''
					_UpperCamelCase									=    '''__test_patch_submodule_successive_rename__'''
					assert _test_patching.os.path.join is original_join
					assert _test_patching.os.path.dirname is original_dirname
					assert _test_patching.os.rename is original_rename

					with patch_submodule(_test_patching,	'''os.path.join''',	__snake_case      ):
										with patch_submodule(_test_patching,	'''os.rename''',	__snake_case      ):
															with patch_submodule(_test_patching,	'''os.path.dirname''',	__snake_case      ):
																				assert _test_patching.os.path.join is mock_join
																				assert _test_patching.os.path.dirname is mock_dirname
																				assert _test_patching.os.rename is mock_rename

    # try another order
					with patch_submodule(_test_patching,	'''os.rename''',	__snake_case      ):
										with patch_submodule(_test_patching,	'''os.path.join''',	__snake_case      ):
															with patch_submodule(_test_patching,	'''os.path.dirname''',	__snake_case      ):
																				assert _test_patching.os.path.join is mock_join
																				assert _test_patching.os.path.dirname is mock_dirname
																				assert _test_patching.os.rename is mock_rename

					assert _test_patching.os.path.join is original_join
					assert _test_patching.os.path.dirname is original_dirname
					assert _test_patching.os.rename is original_rename



def  lowerCamelCase__						(     )				->						str:


					"""simple docstring"""





					_UpperCamelCase									=    '''__test_patch_submodule_doesnt_exist_mock__'''
					with patch_submodule(_test_patching,	'''__module_that_doesn_exist__.__attribute_that_doesn_exist__''',	__snake_case      ):
										pass
					with patch_submodule(_test_patching,	'''os.__attribute_that_doesn_exist__''',	__snake_case      ):
										pass






