


'''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											=					logging.get_logger(__name__)

__snake_case											=					'''Hello, World!'''
__snake_case											=					'''en_XX'''


def       a		(      __a			, __a			, __a       )  ->     str:



					'''simple docstring'''






					UpperCamelCase__       :Optional[int]							 =			Path('''data_bin'''       )
					UpperCamelCase__       :Tuple							 =			FairseqXmodModel.from_pretrained(
					    model_name_or_path=str(Path(__a       ).parent       )			, checkpoint_file=Path(__a       ).name			, _name='''xmod_base'''			, arch='''xmod_base'''			, task='''multilingual_masked_lm'''			, data_name_or_path=str(__a       )			, bpe='''sentencepiece'''			, sentencepiece_model=str(Path(__a       ).parent / '''sentencepiece.bpe.model'''       )			, src_dict=str(data_dir / '''dict.txt'''       )			, )
					xmod.eval()  # disable dropout
					print(__a       )

					UpperCamelCase__       :Any							 =			xmod.model.encoder.sentence_encoder
					UpperCamelCase__       :List[str]							 =			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:
										UpperCamelCase__       :List[Any]							 =			xmod.model.classification_heads['''mnli'''].out_proj.weight.shape[0]

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

					UpperCamelCase__       :Tuple							 =			XmodForSequenceClassification(__a       ) if classification_head else XmodForMaskedLM(__a       )
					model.eval()

					# Now let's copy all the weights.
					# Embeddings
					UpperCamelCase__       :Union[str, Any]							 =			xmod_sent_encoder.embed_tokens.weight
					UpperCamelCase__       :List[Any]							 =			xmod_sent_encoder.embed_positions.weight
					UpperCamelCase__       :Optional[int]							 =			torch.zeros_like(
					    model.roberta.embeddings.token_type_embeddings.weight       )  # just zero them out b/c xmod doesn't use them.

					UpperCamelCase__       :List[Any]							 =			xmod_sent_encoder.layernorm_embedding.weight
					UpperCamelCase__       :Optional[int]							 =			xmod_sent_encoder.layernorm_embedding.bias

					for i in range(config.num_hidden_layers       ):
										# Encoder: start of layer
										UpperCamelCase__       :List[str]							 =			model.roberta.encoder.layer[i]
										UpperCamelCase__       :Optional[Any]							 =			xmod_sent_encoder.layers[i]

										# self attention
										UpperCamelCase__       :List[Any]							 =			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.'''       )

										UpperCamelCase__       :Tuple							 =			xmod_layer.self_attn.q_proj.weight
										UpperCamelCase__       :int							 =			xmod_layer.self_attn.q_proj.bias
										UpperCamelCase__       :Dict							 =			xmod_layer.self_attn.k_proj.weight
										UpperCamelCase__       :str							 =			xmod_layer.self_attn.k_proj.bias
										UpperCamelCase__       :Optional[int]							 =			xmod_layer.self_attn.v_proj.weight
										UpperCamelCase__       :List[Any]							 =			xmod_layer.self_attn.v_proj.bias

										# self-attention output
										UpperCamelCase__       :str							 =			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.'''       )
										UpperCamelCase__       :int							 =			xmod_layer.self_attn.out_proj.weight
										UpperCamelCase__       :Dict							 =			xmod_layer.self_attn.out_proj.bias
										UpperCamelCase__       :List[Any]							 =			xmod_layer.self_attn_layer_norm.weight
										UpperCamelCase__       :int							 =			xmod_layer.self_attn_layer_norm.bias

										# intermediate
										UpperCamelCase__       :Dict							 =			layer.intermediate
										if intermediate.dense.weight.shape != xmod_layer.fca.weight.shape:
															raise AssertionError('''Dimensions of intermediate weights do not match.'''       )
										UpperCamelCase__       :Tuple							 =			xmod_layer.fca.weight
										UpperCamelCase__       :Optional[int]							 =			xmod_layer.fca.bias

										# output
										UpperCamelCase__       :List[Any]							 =			layer.output
										if bert_output.dense.weight.shape != xmod_layer.fca.weight.shape:
															raise AssertionError('''Dimensions of feed-forward weights do not match.'''       )
										UpperCamelCase__       :str							 =			xmod_layer.fca.weight
										UpperCamelCase__       :str							 =			xmod_layer.fca.bias
										UpperCamelCase__       :Optional[Any]							 =			xmod_layer.final_layer_norm.weight
										UpperCamelCase__       :List[str]							 =			xmod_layer.final_layer_norm.bias
										if bert_output.adapter_layer_norm is not None:
															UpperCamelCase__       :int							 =			xmod_layer.adapter_layer_norm.weight
															UpperCamelCase__       :Union[str, Any]							 =			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():
															UpperCamelCase__       :Dict							 =			bert_output.adapter_modules[lang_code]
															UpperCamelCase__       :Union[str, Any]							 =			xmod_layer.adapter_modules[lang_code]
															UpperCamelCase__       :Any							 =			from_adapter.fca.weight
															UpperCamelCase__       :str							 =			from_adapter.fca.bias
															UpperCamelCase__       :Optional[int]							 =			from_adapter.fca.weight
															UpperCamelCase__       :Optional[Any]							 =			from_adapter.fca.bias

										# end of layer

					if xmod_sent_encoder.layer_norm is not None:
										UpperCamelCase__       :List[Any]							 =			xmod_sent_encoder.layer_norm.weight
										UpperCamelCase__       :int							 =			xmod_sent_encoder.layer_norm.bias

					if classification_head:
										UpperCamelCase__       :Optional[int]							 =			xmod.model.classification_heads['''mnli'''].dense.weight
										UpperCamelCase__       :str							 =			xmod.model.classification_heads['''mnli'''].dense.bias
										UpperCamelCase__       :int							 =			xmod.model.classification_heads['''mnli'''].out_proj.weight
										UpperCamelCase__       :List[Any]							 =			xmod.model.classification_heads['''mnli'''].out_proj.bias
					else:
										# LM Head
										UpperCamelCase__       :Optional[int]							 =			xmod.model.encoder.lm_head.dense.weight
										UpperCamelCase__       :Any							 =			xmod.model.encoder.lm_head.dense.bias
										UpperCamelCase__       :str							 =			xmod.model.encoder.lm_head.layer_norm.weight
										UpperCamelCase__       :int							 =			xmod.model.encoder.lm_head.layer_norm.bias
										UpperCamelCase__       :Any							 =			xmod.model.encoder.lm_head.weight
										UpperCamelCase__       :List[Any]							 =			xmod.model.encoder.lm_head.bias

					# Let's check that we get the same results.
					UpperCamelCase__       :Union[str, Any]							 =			xmod.encode(__a       ).unsqueeze(0       )  # batch of size 1
					model.roberta.set_default_language(__a       )

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

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


if __name__ == "__main__":
		__snake_case											=					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											=					parser.parse_args()
		convert_xmod_checkpoint_to_pytorch(
		    args.xmod_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
		)



'''simple docstring'''
import argparse
from collections import defaultdict

import yaml


__snake_case											=					'''docs/source/en/_toctree.yml'''


def       a				(      __a       )  ->     int:



					'''simple docstring'''






					UpperCamelCase__       :int							 =			defaultdict(__a       )
					UpperCamelCase__       :int							 =			[]
					UpperCamelCase__       :int							 =			[]
					for doc in doc_list:
										if "local" in doc:
															counts[doc["local"]] += 1

										if doc["title"].lower() == "overview":
															overview_doc.append({'''local''': doc['''local'''], '''title''': doc['''title''']}       )
										else:
															new_doc_list.append(__a       )

					UpperCamelCase__       :Union[str, Any]							 =			new_doc_list
					UpperCamelCase__       :Tuple							 =			[key for key, value in counts.items() if value > 1]

					UpperCamelCase__       :Union[str, Any]							 =			[]
					for duplicate_key in duplicates:
										UpperCamelCase__       :Dict							 =			list({doc['''title'''] for doc in doc_list if doc['''local'''] == duplicate_key}       )
										if len(__a       ) > 1:
															raise ValueError(
															    f'''{duplicate_key} is present several times in the documentation table of content at '''
															    '''`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the '''
															    '''others.'''       )
										# Only add this once
										new_doc.append({'''local''': duplicate_key, '''title''': titles[0]}       )

					# Add none duplicate-keys
					new_doc.extend([doc for doc in doc_list if '''local''' not in counts or counts[doc['''local''']] == 1]       )
					UpperCamelCase__       :Union[str, Any]							 =			sorted(__a			, key=lambda __a       : s["title"].lower()       )

					# "overview" gets special treatment and is always first
					if len(__a       ) > 1:
										raise ValueError('''{doc_list} has two \'overview\' docs which is not allowed.'''       )

					overview_doc.extend(__a       )

					# Sort
					return overview_doc


def       a				(      __a=False       )  ->     Any:



					'''simple docstring'''






					with open(__a			, encoding='''utf-8'''       ) as f:
										UpperCamelCase__       :Any							 =			yaml.safe_load(f.read()       )

					# Get to the API doc
					UpperCamelCase__       :str							 =			0
					while content[api_idx]["title"] != "API":
										api_idx += 1
					UpperCamelCase__       :str							 =			content[api_idx]['''sections''']

					# Then to the model doc
					UpperCamelCase__       :Optional[Any]							 =			0
					while api_doc[scheduler_idx]["title"] != "Schedulers":
										scheduler_idx += 1

					UpperCamelCase__       :List[Any]							 =			api_doc[scheduler_idx]['''sections''']
					UpperCamelCase__       :Union[str, Any]							 =			clean_doc_toc(__a       )

					UpperCamelCase__       :List[Any]							 =			False
					if new_scheduler_doc != scheduler_doc:
										UpperCamelCase__       :Optional[int]							 =			True
										if overwrite:
															UpperCamelCase__       :Dict							 =			new_scheduler_doc

					if diff:
										if overwrite:
															UpperCamelCase__       :Any							 =			api_doc
															with open(__a			, '''w'''			, encoding='''utf-8'''       ) as f:
																				f.write(yaml.dump(__a			, allow_unicode=__a       )       )
										else:
															raise ValueError(
															    '''The model doc part of the table of content is not properly sorted, run `make style` to fix this.'''       )


def       a				(      __a=False       )  ->     Optional[Any]:



					'''simple docstring'''






					with open(__a			, encoding='''utf-8'''       ) as f:
										UpperCamelCase__       :str							 =			yaml.safe_load(f.read()       )

					# Get to the API doc
					UpperCamelCase__       :Optional[Any]							 =			0
					while content[api_idx]["title"] != "API":
										api_idx += 1
					UpperCamelCase__       :Any							 =			content[api_idx]['''sections''']

					# Then to the model doc
					UpperCamelCase__       :str							 =			0
					while api_doc[pipeline_idx]["title"] != "Pipelines":
										pipeline_idx += 1

					UpperCamelCase__       :Any							 =			False
					UpperCamelCase__       :Union[str, Any]							 =			api_doc[pipeline_idx]['''sections''']
					UpperCamelCase__       :Tuple							 =			[]

					# sort sub pipeline docs
					for pipeline_doc in pipeline_docs:
										if "section" in pipeline_doc:
															UpperCamelCase__       :Dict							 =			pipeline_doc['''section''']
															UpperCamelCase__       :Optional[Any]							 =			clean_doc_toc(__a       )
															if overwrite:
																				UpperCamelCase__       :Optional[int]							 =			new_sub_pipeline_doc
										new_pipeline_docs.append(__a       )

					# sort overall pipeline doc
					UpperCamelCase__       :Optional[Any]							 =			clean_doc_toc(__a       )

					if new_pipeline_docs != pipeline_docs:
										UpperCamelCase__       :int							 =			True
										if overwrite:
															UpperCamelCase__       :Union[str, Any]							 =			new_pipeline_docs

					if diff:
										if overwrite:
															UpperCamelCase__       :Dict							 =			api_doc
															with open(__a			, '''w'''			, encoding='''utf-8'''       ) as f:
																				f.write(yaml.dump(__a			, allow_unicode=__a       )       )
										else:
															raise ValueError(
															    '''The model doc part of the table of content is not properly sorted, run `make style` to fix this.'''       )


if __name__ == "__main__":
		__snake_case											=					argparse.ArgumentParser()
		parser.add_argument('''--fix_and_overwrite''', action='''store_true''', help='''Whether to fix inconsistencies.''')
		__snake_case											=					parser.parse_args()

		check_scheduler_doc(args.fix_and_overwrite)
		check_pipeline_doc(args.fix_and_overwrite)