



import unittest

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

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    LayoutLMForMaskedLM,
							    LayoutLMForQuestionAnswering,
							    LayoutLMForSequenceClassification,
							    LayoutLMForTokenClassification,
							    LayoutLMModel,
							)







class      __lowerCAmelCase       :



			def __init__(		self  :    Optional[Any]					,						A  :    List[str]					,						A  :    List[str]=13					,						A  :    List[str]=7					,						A  :    Union[str, Any]=True					,						A  :    Dict=True					,						A  :    List[Any]=True					,						A  :    Optional[Any]=True					,						A  :    Tuple=99					,						A  :    int=32					,						A  :    Any=5					,						A  :    str=4					,						A  :    Dict=37					,						A  :    Optional[Any]="gelu"					,						A  :    Optional[int]=0.1					,						A  :    Optional[int]=0.1					,						A  :    List[Any]=5_12					,						A  :    Tuple=16					,						A  :    Dict=2					,						A  :    Tuple=0.0_2					,						A  :    Optional[int]=3					,						A  :    Dict=4					,						A  :    Optional[int]=None					,						A  :    Union[str, Any]=10_00					,						)  ->       Dict:



						"""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        _lowerCamelCase			(		self  :    Optional[int])  ->       Any:



						"""simple docstring"""






						_UpperCAmelCase									=  ids_tensor([self.batch_size, self.seq_length]					,						self.vocab_size)

						_UpperCAmelCase									=  ids_tensor([self.batch_size, self.seq_length, 4]					,						self.range_bbox)
						# 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									=  None
						if self.use_input_mask:
									_UpperCAmelCase									=  ids_tensor([self.batch_size, self.seq_length]					,						vocab_size=2)

						_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									=  self.get_config()

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



			def        _lowerCamelCase			(		self  :    Optional[Any])  ->       Optional[int]:



						"""simple docstring"""






						return 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					,						)



			def        _lowerCamelCase			(		self  :    int					,						A  :    List[str]					,						A  :    Optional[int]					,						A  :    str					,						A  :    Tuple					,						A  :    int					,						A  :    Optional[Any]					,						A  :    Tuple					,						A  :    Union[str, Any])  ->       Union[str, Any]:



						"""simple docstring"""






						_UpperCAmelCase									=  LayoutLMModel(config=A)
						model.to(A)
						model.eval()
						_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        _lowerCamelCase			(		self  :    Any					,						A  :    int					,						A  :    List[str]					,						A  :    Optional[int]					,						A  :    Any					,						A  :    Tuple					,						A  :    List[Any]					,						A  :    Union[str, Any]					,						A  :    Optional[Any])  ->       Optional[Any]:



						"""simple docstring"""






						_UpperCAmelCase									=  LayoutLMForMaskedLM(config=A)
						model.to(A)
						model.eval()
						_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        _lowerCamelCase			(		self  :    Dict					,						A  :    List[str]					,						A  :    Union[str, Any]					,						A  :    Optional[int]					,						A  :    List[Any]					,						A  :    List[str]					,						A  :    Any					,						A  :    Any					,						A  :    Tuple)  ->       Dict:



						"""simple docstring"""






						_UpperCAmelCase									=  self.num_labels
						_UpperCAmelCase									=  LayoutLMForSequenceClassification(A)
						model.to(A)
						model.eval()
						_UpperCAmelCase									=  model(
						    A					,						A					,						attention_mask=A					,						token_type_ids=A					,						labels=A)
						self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.num_labels))



			def        _lowerCamelCase			(		self  :    str					,						A  :    List[Any]					,						A  :    List[str]					,						A  :    str					,						A  :    Union[str, Any]					,						A  :    int					,						A  :    Optional[int]					,						A  :    List[str]					,						A  :    Optional[int])  ->       int:



						"""simple docstring"""






						_UpperCAmelCase									=  self.num_labels
						_UpperCAmelCase									=  LayoutLMForTokenClassification(config=A)
						model.to(A)
						model.eval()
						_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        _lowerCamelCase			(		self  :    List[Any]					,						A  :    Optional[Any]					,						A  :    Any					,						A  :    Any					,						A  :    int					,						A  :    List[str]					,						A  :    List[Any]					,						A  :    Optional[Any]					,						A  :    Union[str, Any])  ->       Tuple:



						"""simple docstring"""






						_UpperCAmelCase									=  LayoutLMForQuestionAnswering(config=A)
						model.to(A)
						model.eval()
						_UpperCAmelCase									=  model(
						    A					,						bbox=A					,						attention_mask=A					,						token_type_ids=A					,						start_positions=A					,						end_positions=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        _lowerCamelCase			(		self  :    List[Any])  ->       Dict:



						"""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_torch
class      __lowerCAmelCase       (     A							,		A							,		unittest.TestCase		):
			UpperCamelCase     =	(
			    (
			        LayoutLMModel,
			        LayoutLMForMaskedLM,
			        LayoutLMForSequenceClassification,
			        LayoutLMForTokenClassification,
			        LayoutLMForQuestionAnswering,
			    )
			    if is_torch_available()
			    else None
			)
			UpperCamelCase     =	(
			    {
			        '''document-question-answering''': LayoutLMForQuestionAnswering,
			        '''feature-extraction''': LayoutLMModel,
			        '''fill-mask''': LayoutLMForMaskedLM,
			        '''text-classification''': LayoutLMForSequenceClassification,
			        '''token-classification''': LayoutLMForTokenClassification,
			        '''zero-shot''': LayoutLMForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			UpperCamelCase     =	True



			def        _lowerCamelCase			(		self  :    str)  ->       str:



						"""simple docstring"""






						_UpperCAmelCase									=  LayoutLMModelTester(self)
						_UpperCAmelCase									=  ConfigTester(self					,						config_class=A					,						hidden_size=37)



			def        _lowerCamelCase			(		self  :    Any)  ->       Dict:



						"""simple docstring"""






						self.config_tester.run_common_tests()



			def        _lowerCamelCase			(		self  :    List[Any])  ->       str:



						"""simple docstring"""






						_UpperCAmelCase									=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*A)



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



						"""simple docstring"""






						_UpperCAmelCase									=  self.model_tester.prepare_config_and_inputs()
						for type in ["absolute", "relative_key", "relative_key_query"]:
									_UpperCAmelCase									=  type
									self.model_tester.create_and_check_model(*A)



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



						"""simple docstring"""






						_UpperCAmelCase									=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_lm(*A)



			def        _lowerCamelCase			(		self  :    Optional[Any])  ->       List[str]:



						"""simple docstring"""






						_UpperCAmelCase									=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(*A)



			def        _lowerCamelCase			(		self  :    int)  ->       str:



						"""simple docstring"""






						_UpperCAmelCase									=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*A)



			def        _lowerCamelCase			(		self  :    List[Any])  ->       List[str]:



						"""simple docstring"""






						_UpperCAmelCase									=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(*A)



			@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.')
			def        _lowerCamelCase			(		self  :    Dict)  ->       Dict:



						"""simple docstring"""






						pass





def 				A      (	)							->					str:







			'''simple docstring'''
			# Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
			# fmt: off
			_UpperCAmelCase									=  torch.tensor([[101,1_019,1_014,1_016,1_037,12_849,4_747,1_004,14_246,2_278,5_439,4_524,5_002,2_930,2_193,2_930,4_341,3_208,1_005,1_055,2_171,2_848,11_300,3_531,102],[101,4_070,4_034,7_020,1_024,3_058,1_015,1_013,2_861,1_013,6_070,19_274,2_772,6_205,27_814,16_147,16_147,4_343,2_047,10_283,10_969,14_389,1_012,2_338,102]]				,  device=_UpperCAmelCase       )  # noqa: E231
			_UpperCAmelCase									=  torch.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],]				,  device=_UpperCAmelCase       )  # noqa: E231
			_UpperCAmelCase									=  torch.tensor([[[0,0,0,0],[423,237,440,251],[427,272,441,287],[419,115,437,129],[961,885,992,912],[256,38,330,58],[256,38,330,58],[336,42,353,57],[360,39,401,56],[360,39,401,56],[411,39,471,59],[479,41,528,59],[533,39,630,60],[67,113,134,131],[141,115,209,132],[68,149,133,166],[141,149,187,164],[195,148,287,165],[195,148,287,165],[195,148,287,165],[295,148,349,165],[441,149,492,166],[497,149,546,164],[64,201,125,218],[1_000,1_000,1_000,1_000]],[[0,0,0,0],[662,150,754,166],[665,199,742,211],[519,213,554,228],[519,213,554,228],[134,433,187,454],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[314,469,376,482],[504,684,582,706],[941,825,973,900],[941,825,973,900],[941,825,973,900],[941,825,973,900],[610,749,652,765],[130,659,168,672],[176,657,237,672],[238,657,312,672],[443,653,628,672],[443,653,628,672],[716,301,825,317],[1_000,1_000,1_000,1_000]]]				,  device=_UpperCAmelCase       )  # noqa: E231
			_UpperCAmelCase									=  torch.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]]				,  device=_UpperCAmelCase       )  # noqa: E231
			# these are sequence labels (i.e. at the token level)
			_UpperCAmelCase									=  torch.tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]]				,  device=_UpperCAmelCase       )  # noqa: E231
			# fmt: on

			return input_ids, attention_mask, bbox, token_type_ids, labels







@require_torch
class      __lowerCAmelCase       (     unittest.TestCase		):



			@slow
			def        _lowerCamelCase			(		self  :    Tuple)  ->       Any:



						"""simple docstring"""






						_UpperCAmelCase									=  LayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased').to(A)

						_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									=  torch.tensor(
						    [[0.1_7_8_5, -0.1_9_4_7, -0.0_4_2_5], [-0.3_2_5_4, -0.2_8_0_7, 0.2_5_5_3], [-0.5_3_9_1, -0.3_3_2_2, 0.3_3_6_4]]					,						device=A					,						)

						self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]					,						A					,						atol=1E-3))

						# test the pooled output on [1, :3]
						_UpperCAmelCase									=  torch.tensor([-0.6_5_8_0, -0.0_2_1_4, 0.8_5_5_2]					,						device=A)

						self.assertTrue(torch.allclose(outputs.pooler_output[1, :3]					,						A					,						atol=1E-3))



			@slow
			def        _lowerCamelCase			(		self  :    Dict)  ->       Optional[int]:



						"""simple docstring"""






						_UpperCAmelCase									=  LayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased'					,						num_labels=2).to(
						    A)

						_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=torch.tensor([1, 1]					,						device=A)					,						)

						# test whether we get a loss as a scalar
						_UpperCAmelCase									=  outputs.loss
						_UpperCAmelCase									=  torch.Size([])
						self.assertEqual(loss.shape					,						A)

						# test the shape of the logits
						_UpperCAmelCase									=  outputs.logits
						_UpperCAmelCase									=  torch.Size((2, 2))
						self.assertEqual(logits.shape					,						A)



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



						"""simple docstring"""






						_UpperCAmelCase									=  LayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased'					,						num_labels=13).to(
						    A)

						_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 loss calculation to be around 2.65
						# expected_loss = torch.tensor(2.65, device=torch_device)

						# The loss is currently somewhat random and can vary between 0.1-0.3 atol.
						# self.assertTrue(torch.allclose(outputs.loss, expected_loss, atol=0.1))

						# test the shape of the logits
						_UpperCAmelCase									=  outputs.logits
						_UpperCAmelCase									=  torch.Size((2, 25, 13))
						self.assertEqual(logits.shape					,						A)



			@slow
			def        _lowerCamelCase			(		self  :    int)  ->       Union[str, Any]:



						"""simple docstring"""






						_UpperCAmelCase									=  LayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased').to(A)

						_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									=  torch.Size((2, 25))
						self.assertEqual(outputs.start_logits.shape					,						A)
						self.assertEqual(outputs.end_logits.shape					,						A)





import argparse

import torch

from transformers import ImageGPTConfig, ImageGPTForCausalLM, load_tf_weights_in_imagegpt
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()





def 				A      (	_UpperCAmelCase							:  Tuple				,  _UpperCAmelCase							:  Any				,  _UpperCAmelCase							:  str       )							->					Union[str, Any]:







			'''simple docstring'''
			# Construct configuration depending on size
			_UpperCAmelCase									=  {'small': (512, 8, 24), 'medium': (1_024, 8, 36), 'large': (1_536, 16, 48)}
			_UpperCAmelCase			,	_UpperCAmelCase			,	_UpperCAmelCase									=  MODELS[model_size]  # set model hyperparameters
			_UpperCAmelCase									=  ImageGPTConfig(n_embd=_UpperCAmelCase				,  n_layer=_UpperCAmelCase				,  n_head=_UpperCAmelCase       )
			_UpperCAmelCase									=  ImageGPTForCausalLM(_UpperCAmelCase       )

			# Load weights from numpy
			load_tf_weights_in_imagegpt(_UpperCAmelCase				,  _UpperCAmelCase				,  _UpperCAmelCase       )

			# Save pytorch-model
			_UpperCAmelCase									=  pytorch_dump_folder_path + '/' + WEIGHTS_NAME
			_UpperCAmelCase									=  pytorch_dump_folder_path + '/' + CONFIG_NAME
			print(F"Save PyTorch model to {pytorch_weights_dump_path}"       )
			torch.save(model.state_dict()				,  _UpperCAmelCase       )
			print(F"Save configuration file to {pytorch_config_dump_path}"       )
			with open(_UpperCAmelCase				,  'w'				,  encoding='utf-8'       ) as f:
						f.write(config.to_json_string()       )


if __name__ == "__main__":
							UpperCAmelCase__  =			argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    "--imagegpt_checkpoint_path",
							    default=None,
							    type=str,
							    required=True,
							    help="Path to the TensorFlow checkpoint path.",
							)
							parser.add_argument(
							    "--model_size",
							    default=None,
							    type=str,
							    required=True,
							    help="Size of the model (can be either 'small', 'medium' or 'large').",
							)
							parser.add_argument(
							    "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
							)
							UpperCAmelCase__  =			parser.parse_args()
							convert_imagegpt_checkpoint_to_pytorch(
							    args.imagegpt_checkpoint_path, args.model_size, args.pytorch_dump_folder_path
							)
