
"""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()
_a :    Optional[Any]														=		logging.get_logger(__name__)

_a :    Union[str, Any]														=		"Hello, World!"
_a :    Optional[Any]														=		"en_XX"



def 				lowerCamelCase__		(      __snake_case,					__snake_case,					__snake_case     )							->		int:


					"""simple docstring"""





					_UpperCamelCase										=  Path('''data_bin'''     )
					_UpperCamelCase										=  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     )

					_UpperCamelCase										=  xmod.model.encoder.sentence_encoder
					_UpperCamelCase										=  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=5_14,					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										=  xmod.model.classification_heads['''mnli'''].out_proj.weight.shape[0]

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

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

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

					_UpperCamelCase										=  xmod_sent_encoder.layernorm_embedding.weight
					_UpperCamelCase										=  xmod_sent_encoder.layernorm_embedding.bias

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

										# self attention
										_UpperCamelCase										=  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										=  xmod_layer.self_attn.q_proj.weight
										_UpperCamelCase										=  xmod_layer.self_attn.q_proj.bias
										_UpperCamelCase										=  xmod_layer.self_attn.k_proj.weight
										_UpperCamelCase										=  xmod_layer.self_attn.k_proj.bias
										_UpperCamelCase										=  xmod_layer.self_attn.v_proj.weight
										_UpperCamelCase										=  xmod_layer.self_attn.v_proj.bias

										# self-attention output
										_UpperCamelCase										=  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										=  xmod_layer.self_attn.out_proj.weight
										_UpperCamelCase										=  xmod_layer.self_attn.out_proj.bias
										_UpperCamelCase										=  xmod_layer.self_attn_layer_norm.weight
										_UpperCamelCase										=  xmod_layer.self_attn_layer_norm.bias

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

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

										# end of layer

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

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

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

					_UpperCamelCase										=  model(__snake_case     )[0]
					if classification_head:
										_UpperCamelCase										=  xmod.model.classification_heads['''mnli'''](xmod.extract_features(__snake_case     )     )
					else:
										_UpperCamelCase										=  xmod.model(__snake_case,					lang_id=[SAMPLE_LANGUAGE]     )[0]
					print(our_output.shape,					their_output.shape     )
					_UpperCamelCase										=  torch.max(torch.abs(our_output - their_output     )     ).item()
					print(F'''max_absolute_diff = {max_absolute_diff}'''     )  # ~ 1e-7
					_UpperCamelCase										=  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__":
				_a :    Optional[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."""
				)
				_a :    Any														=		parser.parse_args()
				convert_xmod_checkpoint_to_pytorch(
				    args.xmod_checkpoint_path, args.pytorch_dump_folder_path, args.classification_head
				)








"""simple docstring"""





from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import tensorflow as tf

				from transformers.models.layoutlm.modeling_tf_layoutlm import (
				    TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFLayoutLMForMaskedLM,
				    TFLayoutLMForQuestionAnswering,
				    TFLayoutLMForSequenceClassification,
				    TFLayoutLMForTokenClassification,
				    TFLayoutLMModel,
				)






class    _UpperCAmelCase:



		def __init__( self    ,		__a    ,		__a=13    ,		__a=7    ,		__a=True    ,		__a=True    ,		__a=True    ,		__a=True    ,		__a=99    ,		__a=32    ,		__a=2    ,		__a=4    ,		__a=37    ,		__a="gelu"    ,		__a=0.1    ,		__a=0.1    ,		__a=5_12    ,		__a=16    ,		__a=2    ,		__a=0.02    ,		__a=3    ,		__a=4    ,		__a=None    ,		__a=10_00    ,		)	->	str:






							'''simple docstring'''
							_UpperCamelCase										=  parent
							_UpperCamelCase										=  batch_size
							_UpperCamelCase										=  seq_length
							_UpperCamelCase										=  is_training
							_UpperCamelCase										=  use_input_mask
							_UpperCamelCase										=  use_token_type_ids
							_UpperCamelCase										=  use_labels
							_UpperCamelCase										=  vocab_size
							_UpperCamelCase										=  hidden_size
							_UpperCamelCase										=  num_hidden_layers
							_UpperCamelCase										=  num_attention_heads
							_UpperCamelCase										=  intermediate_size
							_UpperCamelCase										=  hidden_act
							_UpperCamelCase										=  hidden_dropout_prob
							_UpperCamelCase										=  attention_probs_dropout_prob
							_UpperCamelCase										=  max_position_embeddings
							_UpperCamelCase										=  type_vocab_size
							_UpperCamelCase										=  type_sequence_label_size
							_UpperCamelCase										=  initializer_range
							_UpperCamelCase										=  num_labels
							_UpperCamelCase										=  num_choices
							_UpperCamelCase										=  scope
							_UpperCamelCase										=  range_bbox



		def 						UpperCAmelCase							( self)	->	Tuple:






							'''simple docstring'''
							_UpperCamelCase										=  ids_tensor([self.batch_size, self.seq_length]    ,		self.vocab_size)

							# convert bbox to numpy since TF does not support item assignment
							_UpperCamelCase										=  ids_tensor([self.batch_size, self.seq_length, 4]    ,		self.range_bbox).numpy()
							# Ensure that bbox is legal
							for i in range(bbox.shape[0]):
												for j in range(bbox.shape[1]):
																	if bbox[i, j, 3] < bbox[i, j, 1]:
																						_UpperCamelCase										=  bbox[i, j, 3]
																						_UpperCamelCase										=  bbox[i, j, 1]
																						_UpperCamelCase										=  t
																	if bbox[i, j, 2] < bbox[i, j, 0]:
																						_UpperCamelCase										=  bbox[i, j, 2]
																						_UpperCamelCase										=  bbox[i, j, 0]
																						_UpperCamelCase										=  t
							_UpperCamelCase										=  tf.convert_to_tensor(__a)

							_UpperCamelCase										=  None
							if self.use_input_mask:
												_UpperCamelCase										=  random_attention_mask([self.batch_size, self.seq_length])

							_UpperCamelCase										=  None
							if self.use_token_type_ids:
												_UpperCamelCase										=  ids_tensor([self.batch_size, self.seq_length]    ,		self.type_vocab_size)

							_UpperCamelCase										=  None
							_UpperCamelCase										=  None
							_UpperCamelCase										=  None
							if self.use_labels:
												_UpperCamelCase										=  ids_tensor([self.batch_size]    ,		self.type_sequence_label_size)
												_UpperCamelCase										=  ids_tensor([self.batch_size, self.seq_length]    ,		self.num_labels)
												_UpperCamelCase										=  ids_tensor([self.batch_size]    ,		self.num_choices)

							_UpperCamelCase										=  LayoutLMConfig(
							    vocab_size=self.vocab_size    ,		hidden_size=self.hidden_size    ,		num_hidden_layers=self.num_hidden_layers    ,		num_attention_heads=self.num_attention_heads    ,		intermediate_size=self.intermediate_size    ,		hidden_act=self.hidden_act    ,		hidden_dropout_prob=self.hidden_dropout_prob    ,		attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,		max_position_embeddings=self.max_position_embeddings    ,		type_vocab_size=self.type_vocab_size    ,		initializer_range=self.initializer_range    ,		)

							return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a)	->	List[str]:






							'''simple docstring'''
							_UpperCamelCase										=  TFLayoutLMModel(config=__a)

							_UpperCamelCase										=  model(__a    ,		__a    ,		attention_mask=__a    ,		token_type_ids=__a)
							_UpperCamelCase										=  model(__a    ,		__a    ,		token_type_ids=__a)
							_UpperCamelCase										=  model(__a    ,		__a)
							self.parent.assertEqual(result.last_hidden_state.shape    ,		(self.batch_size, self.seq_length, self.hidden_size))
							self.parent.assertEqual(result.pooler_output.shape    ,		(self.batch_size, self.hidden_size))



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a)	->	Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase										=  TFLayoutLMForMaskedLM(config=__a)

							_UpperCamelCase										=  model(__a    ,		__a    ,		attention_mask=__a    ,		token_type_ids=__a    ,		labels=__a)
							self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.seq_length, self.vocab_size))



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a)	->	int:






							'''simple docstring'''
							_UpperCamelCase										=  self.num_labels
							_UpperCamelCase										=  TFLayoutLMForSequenceClassification(config=__a)

							_UpperCamelCase										=  model(__a    ,		__a    ,		attention_mask=__a    ,		token_type_ids=__a)
							self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.num_labels))



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a)	->	Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase										=  self.num_labels
							_UpperCamelCase										=  TFLayoutLMForTokenClassification(config=__a)

							_UpperCamelCase										=  model(__a    ,		__a    ,		attention_mask=__a    ,		token_type_ids=__a    ,		labels=__a)
							self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.seq_length, self.num_labels))



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a    ,		__a)	->	Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase										=  TFLayoutLMForQuestionAnswering(config=__a)

							_UpperCamelCase										=  model(__a    ,		__a    ,		attention_mask=__a    ,		token_type_ids=__a)
							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 						UpperCAmelCase							( self)	->	List[Any]:






							'''simple docstring'''
							_UpperCamelCase										=  self.prepare_config_and_inputs()
							(
							    (
							    _UpperCamelCase
							)			,  (
							    _UpperCamelCase
							)			,  (
							    _UpperCamelCase
							)			,  (
							    _UpperCamelCase
							)			,  (
							    _UpperCamelCase
							)			,  (
							    _UpperCamelCase
							)			,  (
							    _UpperCamelCase
							)			,  (
							    _UpperCamelCase
							)			,  
							)										=  config_and_inputs
							_UpperCamelCase										=  {
							    '''input_ids''': input_ids,
							    '''bbox''': bbox,
							    '''token_type_ids''': token_type_ids,
							    '''attention_mask''': input_mask,
							}
							return config, inputs_dict






@require_tf
class    _UpperCAmelCase(   lowerCamelCase				,					lowerCamelCase				,					unittest.TestCase     ):
		lowercase__      =				(
		    (
		        TFLayoutLMModel,
		        TFLayoutLMForMaskedLM,
		        TFLayoutLMForTokenClassification,
		        TFLayoutLMForSequenceClassification,
		        TFLayoutLMForQuestionAnswering,
		    )
		    if is_tf_available()
		    else ()
		)
		lowercase__      =				(
		    {
		        'feature-extraction': TFLayoutLMModel,
		        'fill-mask': TFLayoutLMForMaskedLM,
		        'text-classification': TFLayoutLMForSequenceClassification,
		        'token-classification': TFLayoutLMForTokenClassification,
		        'zero-shot': TFLayoutLMForSequenceClassification,
		    }
		    if is_tf_available()
		    else {}
		)
		lowercase__      =				False
		lowercase__      =				True
		lowercase__      =				10



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






							'''simple docstring'''
							_UpperCamelCase										=  TFLayoutLMModelTester(self)
							_UpperCamelCase										=  ConfigTester(self    ,		config_class=__a    ,		hidden_size=37)



		def 						UpperCAmelCase							( self)	->	str:






							'''simple docstring'''
							self.config_tester.run_common_tests()



		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__a)



		def 						UpperCAmelCase							( self)	->	Dict:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*__a)



		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*__a)



		def 						UpperCAmelCase							( self)	->	Optional[int]:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*__a)



		def 						UpperCAmelCase							( self)	->	Tuple:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*__a)



		@slow
		def 						UpperCAmelCase							( self)	->	str:






							'''simple docstring'''
							for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase										=  TFLayoutLMModel.from_pretrained(__a)
												self.assertIsNotNone(__a)




		@unittest.skip('''Onnx compliancy broke with TF 2.10''')
		def 						UpperCAmelCase							( self)	->	List[str]:






							'''simple docstring'''
							pass





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


					"""simple docstring"""





					_UpperCamelCase										=  tf.convert_to_tensor([[1_01,10_19,10_14,10_16,10_37,1_28_49,47_47,10_04,1_42_46,22_78,54_39,45_24,50_02,29_30,21_93,29_30,43_41,32_08,10_05,10_55,21_71,28_48,1_13_00,35_31,1_02],[1_01,40_70,40_34,70_20,10_24,30_58,10_15,10_13,28_61,10_13,60_70,1_92_74,27_72,62_05,2_78_14,1_61_47,1_61_47,43_43,20_47,1_02_83,1_09_69,1_43_89,10_12,23_38,1_02]]     )  # noqa: E231
					_UpperCamelCase										=  tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]     )  # noqa: E231
					_UpperCamelCase										=  tf.convert_to_tensor([[[0,0,0,0],[4_23,2_37,4_40,2_51],[4_27,2_72,4_41,2_87],[4_19,1_15,4_37,1_29],[9_61,8_85,9_92,9_12],[2_56,38,3_30,58],[2_56,38,3_30,58],[3_36,42,3_53,57],[3_60,39,4_01,56],[3_60,39,4_01,56],[4_11,39,4_71,59],[4_79,41,5_28,59],[5_33,39,6_30,60],[67,1_13,1_34,1_31],[1_41,1_15,2_09,1_32],[68,1_49,1_33,1_66],[1_41,1_49,1_87,1_64],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[2_95,1_48,3_49,1_65],[4_41,1_49,4_92,1_66],[4_97,1_49,5_46,1_64],[64,2_01,1_25,2_18],[10_00,10_00,10_00,10_00]],[[0,0,0,0],[6_62,1_50,7_54,1_66],[6_65,1_99,7_42,2_11],[5_19,2_13,5_54,2_28],[5_19,2_13,5_54,2_28],[1_34,4_33,1_87,4_54],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[3_14,4_69,3_76,4_82],[5_04,6_84,5_82,7_06],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[6_10,7_49,6_52,7_65],[1_30,6_59,1_68,6_72],[1_76,6_57,2_37,6_72],[2_38,6_57,3_12,6_72],[4_43,6_53,6_28,6_72],[4_43,6_53,6_28,6_72],[7_16,3_01,8_25,3_17],[10_00,10_00,10_00,10_00]]]     )  # noqa: E231
					_UpperCamelCase										=  tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]     )  # noqa: E231
					# these are sequence labels (i.e. at the token level)
					_UpperCamelCase										=  tf.convert_to_tensor([[-1_00,10,10,10,9,1,-1_00,7,7,-1_00,7,7,4,2,5,2,8,8,-1_00,-1_00,5,0,3,2,-1_00],[-1_00,12,12,12,-1_00,12,10,-1_00,-1_00,-1_00,-1_00,10,12,9,-1_00,-1_00,-1_00,10,10,10,9,12,-1_00,10,-1_00]]     )  # noqa: E231
					# fmt: on

					return input_ids, attention_mask, bbox, token_type_ids, labels






@require_tf
class    _UpperCAmelCase(   unittest.TestCase     ):



		@slow
		def 						UpperCAmelCase							( self)	->	Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase										=  TFLayoutLMModel.from_pretrained('''microsoft/layoutlm-base-uncased''')

							_UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase										=  prepare_layoutlm_batch_inputs()

							# forward pass
							_UpperCamelCase										=  model(input_ids=__a    ,		bbox=__a    ,		attention_mask=__a    ,		token_type_ids=__a)

							# test the sequence output on [0, :3, :3]
							_UpperCamelCase										=  tf.convert_to_tensor(
							    [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]    ,		)

							self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]    ,		__a    ,		atol=1e-3))

							# test the pooled output on [1, :3]
							_UpperCamelCase										=  tf.convert_to_tensor([-0.6580, -0.0214, 0.8552])

							self.assertTrue(np.allclose(outputs.pooler_output[1, :3]    ,		__a    ,		atol=1e-3))



		@slow
		def 						UpperCAmelCase							( self)	->	Any:






							'''simple docstring'''
							# initialize model with randomly initialized sequence classification head
							_UpperCamelCase										=  TFLayoutLMForSequenceClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''    ,		num_labels=2)

							_UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase										=  prepare_layoutlm_batch_inputs()

							# forward pass
							_UpperCamelCase										=  model(
							    input_ids=__a    ,		bbox=__a    ,		attention_mask=__a    ,		token_type_ids=__a    ,		labels=tf.convert_to_tensor([1, 1])    ,		)

							# test whether we get a loss as a scalar
							_UpperCamelCase										=  outputs.loss
							_UpperCamelCase										=  (2,)
							self.assertEqual(loss.shape    ,		__a)

							# test the shape of the logits
							_UpperCamelCase										=  outputs.logits
							_UpperCamelCase										=  (2, 2)
							self.assertEqual(logits.shape    ,		__a)



		@slow
		def 						UpperCAmelCase							( self)	->	List[str]:






							'''simple docstring'''
							# initialize model with randomly initialized token classification head
							_UpperCamelCase										=  TFLayoutLMForTokenClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''    ,		num_labels=13)

							_UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase										=  prepare_layoutlm_batch_inputs()

							# forward pass
							_UpperCamelCase										=  model(
							    input_ids=__a    ,		bbox=__a    ,		attention_mask=__a    ,		token_type_ids=__a    ,		labels=__a)

							# test the shape of the logits
							_UpperCamelCase										=  outputs.logits
							_UpperCamelCase										=  tf.convert_to_tensor((2, 25, 13))
							self.assertEqual(logits.shape    ,		__a)




		@slow
		def 						UpperCAmelCase							( self)	->	Dict:






							'''simple docstring'''
							# initialize model with randomly initialized token classification head
							_UpperCamelCase										=  TFLayoutLMForQuestionAnswering.from_pretrained('''microsoft/layoutlm-base-uncased''')

							_UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase			,  _UpperCamelCase										=  prepare_layoutlm_batch_inputs()

							# forward pass
							_UpperCamelCase										=  model(input_ids=__a    ,		bbox=__a    ,		attention_mask=__a    ,		token_type_ids=__a)

							# test the shape of the logits
							_UpperCamelCase										=  tf.convert_to_tensor((2, 25))
							self.assertEqual(outputs.start_logits.shape    ,		__a)
							self.assertEqual(outputs.end_logits.shape    ,		__a)






