import argparse
import json
import os
from collections import OrderedDict

import torch

from transformers import LukeConfig, LukeForMaskedLM, MLukeTokenizer, XLMRobertaTokenizer
from transformers.tokenization_utils_base import AddedToken
@torch.no_grad()
def 					_snake_case	(  __snake_case  ,     __snake_case  ,     __snake_case  ,     __snake_case  ,     __snake_case						):
					# Load configuration defined in the metadata file
					with open(__snake_case						) as metadata_file:
										_UpperCamelCase			     =     json.load(__snake_case						)
					_UpperCamelCase			     =     LukeConfig(use_entity_aware_attention=__snake_case  ,     **metadata['''model_config''']						)

					# Load in the weights from the checkpoint_path
					_UpperCamelCase			     =     torch.load(__snake_case  ,     map_location='''cpu'''						)['''module''']

					# Load the entity vocab file
					_UpperCamelCase			     =     load_original_entity_vocab(__snake_case						)
					# add an entry for [MASK2]
					_UpperCamelCase			     =     max(entity_vocab.values()						) + 1
					config.entity_vocab_size += 1

					_UpperCamelCase			     =     XLMRobertaTokenizer.from_pretrained(metadata['''model_config''']['''bert_model_name''']						)

					# Add special tokens to the token vocabulary for downstream tasks
					_UpperCamelCase			     =     AddedToken('''<ent>'''  ,     lstrip=__snake_case  ,     rstrip=__snake_case						)
					_UpperCamelCase			     =     AddedToken('''<ent2>'''  ,     lstrip=__snake_case  ,     rstrip=__snake_case						)
					tokenizer.add_special_tokens({'''additional_special_tokens''': [entity_token_a, entity_token_a]}						)
					config.vocab_size += 2

					print(f"""Saving tokenizer to {pytorch_dump_folder_path}"""						)
					tokenizer.save_pretrained(__snake_case						)
					with open(os.path.join(__snake_case  ,     '''tokenizer_config.json'''						)  ,     '''r'''						) as f:
										_UpperCamelCase			     =     json.load(__snake_case						)
					_UpperCamelCase			     =     '''MLukeTokenizer'''
					with open(os.path.join(__snake_case  ,     '''tokenizer_config.json'''						)  ,     '''w'''						) as f:
										json.dump(__snake_case  ,     __snake_case						)

					with open(os.path.join(__snake_case  ,     MLukeTokenizer.vocab_files_names['''entity_vocab_file''']						)  ,     '''w'''						) as f:
										json.dump(__snake_case  ,     __snake_case						)

					_UpperCamelCase			     =     MLukeTokenizer.from_pretrained(__snake_case						)

					# Initialize the embeddings of the special tokens
					_UpperCamelCase			     =     tokenizer.convert_tokens_to_ids(['''@''']						)[0]
					_UpperCamelCase			     =     tokenizer.convert_tokens_to_ids(['''#''']						)[0]

					_UpperCamelCase			     =     state_dict['''embeddings.word_embeddings.weight''']
					_UpperCamelCase			     =     word_emb[ent_init_index].unsqueeze(0						)
					_UpperCamelCase			     =     word_emb[enta_init_index].unsqueeze(0						)
					_UpperCamelCase			     =     torch.cat([word_emb, ent_emb, enta_emb]						)
					# add special tokens for 'entity_predictions.bias'
					for bias_name in ["lm_head.decoder.bias", "lm_head.bias"]:
										_UpperCamelCase			     =     state_dict[bias_name]
										_UpperCamelCase			     =     decoder_bias[ent_init_index].unsqueeze(0						)
										_UpperCamelCase			     =     decoder_bias[enta_init_index].unsqueeze(0						)
										_UpperCamelCase			     =     torch.cat([decoder_bias, ent_decoder_bias, enta_decoder_bias]						)

					# Initialize the query layers of the entity-aware self-attention mechanism
					for layer_index in range(config.num_hidden_layers						):
										for matrix_name in ["query.weight", "query.bias"]:
															_UpperCamelCase			     =     f"""encoder.layer.{layer_index}.attention.self."""
															_UpperCamelCase			     =     state_dict[prefix + matrix_name]
															_UpperCamelCase			     =     state_dict[prefix + matrix_name]
															_UpperCamelCase			     =     state_dict[prefix + matrix_name]

    # Initialize the embedding of the [MASK2] entity using that of the [MASK] entity for downstream tasks
					_UpperCamelCase			     =     state_dict['''entity_embeddings.entity_embeddings.weight''']
					_UpperCamelCase			     =     entity_emb[entity_vocab['''[MASK]''']].unsqueeze(0						)
					_UpperCamelCase			     =     torch.cat([entity_emb, entity_mask_emb]						)
					# add [MASK2] for 'entity_predictions.bias'
					_UpperCamelCase			     =     state_dict['''entity_predictions.bias''']
					_UpperCamelCase			     =     entity_prediction_bias[entity_vocab['''[MASK]''']].unsqueeze(0						)
					_UpperCamelCase			     =     torch.cat([entity_prediction_bias, entity_mask_bias]						)

					_UpperCamelCase			     =     LukeForMaskedLM(config=__snake_case						).eval()

					state_dict.pop('''entity_predictions.decoder.weight'''						)
					state_dict.pop('''lm_head.decoder.weight'''						)
					state_dict.pop('''lm_head.decoder.bias'''						)
					_UpperCamelCase			     =     OrderedDict()
					for key, value in state_dict.items():
										if not (key.startswith('''lm_head'''						) or key.startswith('''entity_predictions'''						)):
															_UpperCamelCase			     =     state_dict[key]
										else:
															_UpperCamelCase			     =     state_dict[key]

					_UpperCamelCase     ,    _UpperCamelCase			     =     model.load_state_dict(__snake_case  ,     strict=__snake_case						)

					if set(__snake_case						) != {"luke.embeddings.position_ids"}:
										raise ValueError(f"""Unexpected unexpected_keys: {unexpected_keys}"""						)
					if set(__snake_case						) != {
					    "lm_head.decoder.weight",
					    "lm_head.decoder.bias",
					    "entity_predictions.decoder.weight",
					}:
										raise ValueError(f"""Unexpected missing_keys: {missing_keys}"""						)

					model.tie_weights()
					assert (model.luke.embeddings.word_embeddings.weight == model.lm_head.decoder.weight).all()
					assert (model.luke.entity_embeddings.entity_embeddings.weight == model.entity_predictions.decoder.weight).all()

					# Check outputs
					_UpperCamelCase			     =     MLukeTokenizer.from_pretrained(__snake_case  ,     task='''entity_classification'''						)

					_UpperCamelCase			     =     '''ISO 639-3 uses the code fas for the dialects spoken across Iran and アフガニスタン (Afghanistan).'''
					_UpperCamelCase			     =     (0, 9)
					_UpperCamelCase			     =     tokenizer(__snake_case  ,     entity_spans=[span]  ,     return_tensors='''pt'''						)

					_UpperCamelCase			     =     model(**__snake_case						)

					# Verify word hidden states
					if model_size == "large":
										raise NotImplementedError
					else:  # base
										_UpperCamelCase			     =     torch.Size((1, 33, 768)						)
										_UpperCamelCase			     =     torch.tensor([[0.0892, 0.0596, -0.2819], [0.0134, 0.1199, 0.0573], [-0.0169, 0.0927, 0.0644]]						)

					if not (outputs.last_hidden_state.shape == expected_shape):
										raise ValueError(
										    f"""Outputs.last_hidden_state.shape is {outputs.last_hidden_state.shape}, Expected shape is {expected_shape}"""						)
					if not torch.allclose(outputs.last_hidden_state[0, :3, :3]  ,     __snake_case  ,     atol=1E-4						):
										raise ValueError

					# Verify entity hidden states
					if model_size == "large":
										raise NotImplementedError
					else:  # base
										_UpperCamelCase			     =     torch.Size((1, 1, 768)						)
										_UpperCamelCase			     =     torch.tensor([[-0.1482, 0.0609, 0.0322]]						)

					if not (outputs.entity_last_hidden_state.shape == expected_shape):
										raise ValueError(
										    f"""Outputs.entity_last_hidden_state.shape is {outputs.entity_last_hidden_state.shape}, Expected shape is"""
										    f""" {expected_shape}"""						)
					if not torch.allclose(outputs.entity_last_hidden_state[0, :3, :3]  ,     __snake_case  ,     atol=1E-4						):
										raise ValueError

					# Verify masked word/entity prediction
					_UpperCamelCase			     =     MLukeTokenizer.from_pretrained(__snake_case						)
					_UpperCamelCase			     =     '''Tokyo is the capital of <mask>.'''
					_UpperCamelCase			     =     (24, 30)
					_UpperCamelCase			     =     tokenizer(__snake_case  ,     entity_spans=[span]  ,     return_tensors='''pt'''						)

					_UpperCamelCase			     =     model(**__snake_case						)

					_UpperCamelCase			     =     encoding['''input_ids'''][0].tolist()
					_UpperCamelCase			     =     input_ids.index(tokenizer.convert_tokens_to_ids('''<mask>'''						)						)
					_UpperCamelCase			     =     outputs.logits[0][mask_position_id].argmax(dim=-1						)
					assert "Japan" == tokenizer.decode(__snake_case						)

					_UpperCamelCase			     =     outputs.entity_logits[0][0].argmax().item()
					_UpperCamelCase			     =     [
					    entity for entity, entity_id in tokenizer.entity_vocab.items() if entity_id == predicted_entity_id
					]
					assert [e for e in multilingual_predicted_entities if e.startswith('''en:'''						)][0] == "en:Japan"

					# Finally, save our PyTorch model and tokenizer
					print('''Saving PyTorch model to {}'''.format(__snake_case						)						)
					model.save_pretrained(__snake_case						)
def 					_snake_case	(  __snake_case						):
					_UpperCamelCase			     =     ['''[MASK]''', '''[PAD]''', '''[UNK]''']

					_UpperCamelCase			     =     [json.loads(__snake_case						) for line in open(__snake_case						)]

					_UpperCamelCase			     =     {}
					for entry in data:
										_UpperCamelCase			     =     entry['''id''']
										for entity_name, language in entry["entities"]:
															if entity_name in SPECIAL_TOKENS:
																				_UpperCamelCase			     =     entity_id
																				break
															_UpperCamelCase			     =     f"""{language}:{entity_name}"""
															_UpperCamelCase			     =     entity_id
					return new_mapping


if __name__ == "__main__":
					_lowerCAmelCase       =		argparse.ArgumentParser()
					# Required parameters
					parser.add_argument("--checkpoint_path", type=str, help="Path to a pytorch_model.bin file.")
					parser.add_argument(
					    "--metadata_path", default=None, type=str, help="Path to a metadata.json file, defining the configuration."
					)
					parser.add_argument(
					    "--entity_vocab_path",
					    default=None,
					    type=str,
					    help="Path to an entity_vocab.tsv file, containing the entity vocabulary.",
					)
					parser.add_argument(
					    "--pytorch_dump_folder_path", default=None, type=str, help="Path to where to dump the output PyTorch model."
					)
					parser.add_argument(
					    "--model_size", default="base", type=str, choices=["base", "large"], help="Size of the model to be converted."
					)
					_lowerCAmelCase       =		parser.parse_args()
					convert_luke_checkpoint(
					    args.checkpoint_path,
					    args.metadata_path,
					    args.entity_vocab_path,
					    args.pytorch_dump_folder_path,
					    args.model_size,
					)




'''simple docstring'''


import unittest

from transformers import XLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers import (
          XLMForMultipleChoice,
          XLMForQuestionAnswering,
          XLMForQuestionAnsweringSimple,
          XLMForSequenceClassification,
          XLMForTokenClassification,
          XLMModel,
          XLMWithLMHeadModel,
      )
      from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST







class 							__magic_name__	:

     """simple docstring"""






     def __init__(   self			,     lowerCamelCase			,     lowerCamelCase=13			,     lowerCamelCase=7			,     lowerCamelCase=True			,     lowerCamelCase=True			,     lowerCamelCase=True			,     lowerCamelCase=True			,     lowerCamelCase=True			,     lowerCamelCase=False			,     lowerCamelCase=False			,     lowerCamelCase=False			,     lowerCamelCase=2			,     lowerCamelCase=99			,     lowerCamelCase=0			,     lowerCamelCase=32			,     lowerCamelCase=5			,     lowerCamelCase=4			,     lowerCamelCase=0.1			,     lowerCamelCase=0.1			,     lowerCamelCase=512			,     lowerCamelCase=2			,     lowerCamelCase=0.02			,     lowerCamelCase=2			,     lowerCamelCase=4			,     lowerCamelCase="last"			,     lowerCamelCase=True			,     lowerCamelCase=None			,     lowerCamelCase=0			,     ):


          '''simple docstring'''





          __A	:       Tuple      =							parent
          __A	:       Optional[Any]      =							batch_size
          __A	:       int      =							seq_length
          __A	:       int      =							is_training
          __A	:       List[str]      =							use_input_lengths
          __A	:       Optional[Any]      =							use_token_type_ids
          __A	:       Any      =							use_labels
          __A	:       Dict      =							gelu_activation
          __A	:       List[str]      =							sinusoidal_embeddings
          __A	:       List[Any]      =							causal
          __A	:       Optional[int]      =							asm
          __A	:       List[Any]      =							n_langs
          __A	:       List[str]      =							vocab_size
          __A	:       Any      =							n_special
          __A	:       Optional[int]      =							hidden_size
          __A	:       Optional[Any]      =							num_hidden_layers
          __A	:       Tuple      =							num_attention_heads
          __A	:       List[str]      =							hidden_dropout_prob
          __A	:       Any      =							attention_probs_dropout_prob
          __A	:       Dict      =							max_position_embeddings
          __A	:       Optional[int]      =							type_sequence_label_size
          __A	:       Tuple      =							initializer_range
          __A	:       List[Any]      =							num_labels
          __A	:       List[Any]      =							num_choices
          __A	:       Any      =							summary_type
          __A	:       List[str]      =							use_proj
          __A	:       List[Any]      =							scope
          __A	:       str      =							bos_token_id


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       int      =							ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size		)
          __A	:       int      =							random_attention_mask([self.batch_size, self.seq_length]		)

          __A	:       Union[str, Any]      =							None
          if self.use_input_lengths:
               __A	:       int      =							(
                   ids_tensor([self.batch_size]			,     vocab_size=2		) + self.seq_length - 2
               )  # small variation of seq_length

          __A	:       Any      =							None
          if self.use_token_type_ids:
               __A	:       Optional[int]      =							ids_tensor([self.batch_size, self.seq_length]			,     self.n_langs		)

          __A	:       int      =							None
          __A	:       Any      =							None
          __A	:       Tuple      =							None
          if self.use_labels:
               __A	:       List[Any]      =							ids_tensor([self.batch_size]			,     self.type_sequence_label_size		)
               __A	:       Optional[Any]      =							ids_tensor([self.batch_size, self.seq_length]			,     self.num_labels		)
               __A	:       int      =							ids_tensor([self.batch_size]			,     2		).float()
               __A	:       List[str]      =							ids_tensor([self.batch_size]			,     self.num_choices		)

          __A	:       List[Any]      =							self.get_config()

          return (
              config,
              input_ids,
              token_type_ids,
              input_lengths,
              sequence_labels,
              token_labels,
              is_impossible_labels,
              choice_labels,
              input_mask,
          )


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          return XLMConfig(
              vocab_size=self.vocab_size			,     n_special=self.n_special			,     emb_dim=self.hidden_size			,     n_layers=self.num_hidden_layers			,     n_heads=self.num_attention_heads			,     dropout=self.hidden_dropout_prob			,     attention_dropout=self.attention_probs_dropout_prob			,     gelu_activation=self.gelu_activation			,     sinusoidal_embeddings=self.sinusoidal_embeddings			,     asm=self.asm			,     causal=self.causal			,     n_langs=self.n_langs			,     max_position_embeddings=self.max_position_embeddings			,     initializer_range=self.initializer_range			,     summary_type=self.summary_type			,     use_proj=self.use_proj			,     num_labels=self.num_labels			,     bos_token_id=self.bos_token_id			,     )


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       Tuple      =							XLMModel(config=lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()
          __A	:       Tuple      =							model(lowerCamelCase			,     lengths=lowerCamelCase			,     langs=lowerCamelCase		)
          __A	:       Dict      =							model(lowerCamelCase			,     langs=lowerCamelCase		)
          __A	:       List[Any]      =							model(lowerCamelCase		)
          self.parent.assertEqual(result.last_hidden_state.shape			,     (self.batch_size, self.seq_length, self.hidden_size)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       str      =							XLMWithLMHeadModel(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       List[str]      =							model(lowerCamelCase			,     token_type_ids=lowerCamelCase			,     labels=lowerCamelCase		)
          self.parent.assertEqual(result.loss.shape			,     ()		)
          self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       str      =							XLMForQuestionAnsweringSimple(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       int      =							model(lowerCamelCase		)

          __A	:       List[str]      =							model(lowerCamelCase			,     start_positions=lowerCamelCase			,     end_positions=lowerCamelCase		)
          __A	:       List[Any]      =							outputs
          self.parent.assertEqual(result.start_logits.shape			,     (self.batch_size, self.seq_length)		)
          self.parent.assertEqual(result.end_logits.shape			,     (self.batch_size, self.seq_length)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       Optional[Any]      =							XLMForQuestionAnswering(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       str      =							model(lowerCamelCase		)

          __A	:       Optional[int]      =							model(
              lowerCamelCase			,     start_positions=lowerCamelCase			,     end_positions=lowerCamelCase			,     cls_index=lowerCamelCase			,     is_impossible=lowerCamelCase			,     p_mask=lowerCamelCase			,     )

          __A	:       Any      =							model(
              lowerCamelCase			,     start_positions=lowerCamelCase			,     end_positions=lowerCamelCase			,     cls_index=lowerCamelCase			,     is_impossible=lowerCamelCase			,     )

          ((__A)  ,)	:       List[str]      =							result_with_labels.to_tuple()

          __A	:       int      =							model(lowerCamelCase			,     start_positions=lowerCamelCase			,     end_positions=lowerCamelCase		)

          ((__A)  ,)	:       List[Any]      =							result_with_labels.to_tuple()

          self.parent.assertEqual(result_with_labels.loss.shape			,     ()		)
          self.parent.assertEqual(result.start_top_log_probs.shape			,     (self.batch_size, model.config.start_n_top)		)
          self.parent.assertEqual(result.start_top_index.shape			,     (self.batch_size, model.config.start_n_top)		)
          self.parent.assertEqual(
              result.end_top_log_probs.shape			,     (self.batch_size, model.config.start_n_top * model.config.end_n_top)		)
          self.parent.assertEqual(
              result.end_top_index.shape			,     (self.batch_size, model.config.start_n_top * model.config.end_n_top)		)
          self.parent.assertEqual(result.cls_logits.shape			,     (self.batch_size,)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       Optional[int]      =							XLMForSequenceClassification(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       str      =							model(lowerCamelCase		)
          __A	:       Optional[int]      =							model(lowerCamelCase			,     labels=lowerCamelCase		)
          self.parent.assertEqual(result.loss.shape			,     ()		)
          self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.type_sequence_label_size)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       str      =							self.num_labels
          __A	:       int      =							XLMForTokenClassification(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       str      =							model(lowerCamelCase			,     attention_mask=lowerCamelCase			,     labels=lowerCamelCase		)
          self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.num_labels)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       Union[str, Any]      =							self.num_choices
          __A	:       Union[str, Any]      =							XLMForMultipleChoice(config=lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()
          __A	:       Union[str, Any]      =							input_ids.unsqueeze(1		).expand(-1			,     self.num_choices			,     -1		).contiguous()
          __A	:       Optional[int]      =							token_type_ids.unsqueeze(1		).expand(-1			,     self.num_choices			,     -1		).contiguous()
          __A	:       Tuple      =							input_mask.unsqueeze(1		).expand(-1			,     self.num_choices			,     -1		).contiguous()
          __A	:       Any      =							model(
              lowerCamelCase			,     attention_mask=lowerCamelCase			,     token_type_ids=lowerCamelCase			,     labels=lowerCamelCase			,     )
          self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_choices)		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       List[Any]      =							self.prepare_config_and_inputs()
          (
              (
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,
          )	:       str      =							config_and_inputs
          __A	:       int      =							{"input_ids": input_ids, "token_type_ids": token_type_ids, "lengths": input_lengths}
          return config, inputs_dict







@require_torch
class 							__magic_name__	(       lowerCAmelCase    ,		lowerCAmelCase    ,		lowerCAmelCase    ,		unittest.TestCase ):

     """simple docstring"""






     lowerCamelCase__       						=				(
         (
             XLMModel,
             XLMWithLMHeadModel,
             XLMForQuestionAnswering,
             XLMForSequenceClassification,
             XLMForQuestionAnsweringSimple,
             XLMForTokenClassification,
             XLMForMultipleChoice,
         )
         if is_torch_available()
         else ()
     )
     lowerCamelCase__       						=				(
         (XLMWithLMHeadModel,) if is_torch_available() else ()
     )  # TODO (PVP): Check other models whether language generation is also applicable
     lowerCamelCase__       						=				(
         {
             'feature-extraction': XLMModel,
             'fill-mask': XLMWithLMHeadModel,
             'question-answering': XLMForQuestionAnsweringSimple,
             'text-classification': XLMForSequenceClassification,
             'text-generation': XLMWithLMHeadModel,
             'token-classification': XLMForTokenClassification,
             'zero-shot': XLMForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase		):


          '''simple docstring'''





          if (
              pipeline_test_casse_name == "QAPipelineTests"
              and tokenizer_name is not None
              and not tokenizer_name.endswith("Fast"		)
          ):
               # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
               # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
               # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
               return True

          return False


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase=False		):


          '''simple docstring'''





          __A	:       Optional[Any]      =							super()._prepare_for_class(lowerCamelCase			,     lowerCamelCase			,     return_labels=lowerCamelCase		)

          if return_labels:
               if model_class.__name__ == "XLMForQuestionAnswering":
                    __A	:       List[Any]      =							torch.zeros(
                        self.model_tester.batch_size			,     dtype=torch.long			,     device=lowerCamelCase		)
                    __A	:       Tuple      =							torch.zeros(
                        self.model_tester.batch_size			,     dtype=torch.long			,     device=lowerCamelCase		)

          return inputs_dict


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Optional[int]      =							XLMModelTester(self		)
          __A	:       Any      =							ConfigTester(self			,     config_class=lowerCamelCase			,     emb_dim=37		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          self.config_tester.run_common_tests()


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Optional[int]      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_model(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Dict      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_lm_head(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Any      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_simple_qa(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       int      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_qa(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Tuple      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_sequence_classif(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Optional[int]      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_token_classif(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       List[Any]      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_for_multiple_choice(*lowerCamelCase		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase=False			,     lowerCamelCase=1		):


          '''simple docstring'''





          self.assertIsInstance(lowerCamelCase			,     lowerCamelCase		)
          self.assertListEqual(
              [isinstance(lowerCamelCase			,     lowerCamelCase		) for iter_attentions in attentions]			,     [True] * len(lowerCamelCase		)		)
          self.assertEqual(len(lowerCamelCase		)			,     (max_length - min_length) * num_beam_groups		)

          for idx, iter_attentions in enumerate(lowerCamelCase		):
               # adds PAD dummy token
               __A	:       Optional[Any]      =							min_length + idx + 1
               __A	:       Optional[int]      =							min_length + idx + 1

               __A	:       List[Any]      =							(
                   batch_size * num_beam_groups,
                   config.num_attention_heads,
                   tgt_len,
                   src_len,
               )
               # check attn size
               self.assertListEqual(
                   [layer_attention.shape for layer_attention in iter_attentions]			,     [expected_shape] * len(lowerCamelCase		)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase=False			,     lowerCamelCase=1		):


          '''simple docstring'''





          self.assertIsInstance(lowerCamelCase			,     lowerCamelCase		)
          self.assertListEqual(
              [isinstance(lowerCamelCase			,     lowerCamelCase		) for iter_hidden_states in hidden_states]			,     [True] * len(lowerCamelCase		)			,     )
          self.assertEqual(len(lowerCamelCase		)			,     (max_length - min_length) * num_beam_groups		)

          for idx, iter_hidden_states in enumerate(lowerCamelCase		):
               # adds PAD dummy token
               __A	:       Dict      =							min_length + idx + 1
               __A	:       Union[str, Any]      =							(batch_size * num_beam_groups, seq_len, config.hidden_size)
               # check hidden size
               self.assertListEqual(
                   [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]			,     [expected_shape] * len(lowerCamelCase		)			,     )
          pass


     @slow
     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __A	:       Any      =							XLMModel.from_pretrained(lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)







@require_torch
class 							__magic_name__	(       unittest.TestCase ):

     """simple docstring"""






     @slow
     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Tuple      =							XLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"		)
          model.to(lowerCamelCase		)
          __A	:       Optional[int]      =							torch.tensor([[14, 447]]			,     dtype=torch.long			,     device=lowerCamelCase		)  # the president
          __A	:       Optional[Any]      =							[
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
              14,
              447,
          ]  # the president the president the president the president the president the president the president the president the president the president
          # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
          __A	:       Union[str, Any]      =							model.generate(lowerCamelCase			,     do_sample=lowerCamelCase		)
          self.assertListEqual(output_ids[0].cpu().numpy().tolist()			,     lowerCamelCase		)

