
"""simple docstring"""




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      UpperCamelCase	:

				"""simple docstring"""



				def __init__(				self		,	lowercase__		,	lowercase__=13		,	lowercase__=7		,	lowercase__=True		,	lowercase__=True		,	lowercase__=True		,	lowercase__=True		,	lowercase__=99		,	lowercase__=32		,	lowercase__=5		,	lowercase__=4		,	lowercase__=37		,	lowercase__="gelu"		,	lowercase__=0.1		,	lowercase__=0.1		,	lowercase__=512		,	lowercase__=16		,	lowercase__=2		,	lowercase__=0.02		,	lowercase__=3		,	lowercase__=4		,	lowercase__=None		,	lowercase__=1000		,	)    ->    List[Any]:
									"""simple docstring"""







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


				def 							A					(				self			)    ->    Union[str, Any]:
									"""simple docstring"""







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

									SCREAMING_SNAKE_CASE				=	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]:
																								SCREAMING_SNAKE_CASE				=	bbox[i, j, 3]
																								SCREAMING_SNAKE_CASE				=	bbox[i, j, 1]
																								SCREAMING_SNAKE_CASE				=	t
																			if bbox[i, j, 2] < bbox[i, j, 0]:
																								SCREAMING_SNAKE_CASE				=	bbox[i, j, 2]
																								SCREAMING_SNAKE_CASE				=	bbox[i, j, 0]
																								SCREAMING_SNAKE_CASE				=	t

									SCREAMING_SNAKE_CASE				=	None
									if self.use_input_mask:
														SCREAMING_SNAKE_CASE				=	ids_tensor([self.batch_size, self.seq_length]		,	vocab_size=2			)

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

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

									SCREAMING_SNAKE_CASE				=	self.get_config()

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


				def 							A					(				self			)    ->    Tuple:
									"""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 							A					(				self		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__			)    ->    Optional[int]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	LayoutLMModel(config=lowercase__			)
									model.to(lowercase__			)
									model.eval()
									SCREAMING_SNAKE_CASE				=	model(lowercase__		,	lowercase__		,	attention_mask=lowercase__		,	token_type_ids=lowercase__			)
									SCREAMING_SNAKE_CASE				=	model(lowercase__		,	lowercase__		,	token_type_ids=lowercase__			)
									SCREAMING_SNAKE_CASE				=	model(lowercase__		,	lowercase__			)
									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 							A					(				self		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__			)    ->    Any:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	LayoutLMForMaskedLM(config=lowercase__			)
									model.to(lowercase__			)
									model.eval()
									SCREAMING_SNAKE_CASE				=	model(lowercase__		,	lowercase__		,	attention_mask=lowercase__		,	token_type_ids=lowercase__		,	labels=lowercase__			)
									self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.seq_length, self.vocab_size)			)


				def 							A					(				self		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__			)    ->    Optional[Any]:
									"""simple docstring"""







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


				def 							A					(				self		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__			)    ->    Optional[Any]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	self.num_labels
									SCREAMING_SNAKE_CASE				=	LayoutLMForTokenClassification(config=lowercase__			)
									model.to(lowercase__			)
									model.eval()
									SCREAMING_SNAKE_CASE				=	model(lowercase__		,	lowercase__		,	attention_mask=lowercase__		,	token_type_ids=lowercase__		,	labels=lowercase__			)
									self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.seq_length, self.num_labels)			)


				def 							A					(				self		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__			)    ->    Optional[int]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	LayoutLMForQuestionAnswering(config=lowercase__			)
									model.to(lowercase__			)
									model.eval()
									SCREAMING_SNAKE_CASE				=	model(
									    lowercase__		,	bbox=lowercase__		,	attention_mask=lowercase__		,	token_type_ids=lowercase__		,	start_positions=lowercase__		,	end_positions=lowercase__		,	)
									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 							A					(				self			)    ->    Tuple:
									"""simple docstring"""







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






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

				"""simple docstring"""



				UpperCAmelCase_				:      Dict						  =				(
				    (
				        LayoutLMModel,
				        LayoutLMForMaskedLM,
				        LayoutLMForSequenceClassification,
				        LayoutLMForTokenClassification,
				        LayoutLMForQuestionAnswering,
				    )
				    if is_torch_available()
				    else None
				)
				UpperCAmelCase_				:      Union[str, Any]						  =				(
				    {
				        "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_				:      Any						  =				True


				def 							A					(				self			)    ->    Dict:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	LayoutLMModelTester(self			)
									SCREAMING_SNAKE_CASE				=	ConfigTester(self		,	config_class=lowercase__		,	hidden_size=37			)


				def 							A					(				self			)    ->    int:
									"""simple docstring"""







									self.config_tester.run_common_tests()


				def 							A					(				self			)    ->    Any:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*lowercase__			)


				def 							A					(				self			)    ->    Optional[int]:
									"""simple docstring"""







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


				def 							A					(				self			)    ->    List[Any]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_lm(*lowercase__			)


				def 							A					(				self			)    ->    Any:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*lowercase__			)


				def 							A					(				self			)    ->    Tuple:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*lowercase__			)


				def 							A					(				self			)    ->    Optional[int]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*lowercase__			)




				@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'			)
				def 							A					(				self			)    ->    int:
									"""simple docstring"""







									pass






def   UpperCamelCase_  (		):
					# Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
					# fmt: off
					SCREAMING_SNAKE_CASE				=	torch.tensor([[1_0_1,1_0_1_9,1_0_1_4,1_0_1_6,1_0_3_7,1_2_8_4_9,4_7_4_7,1_0_0_4,1_4_2_4_6,2_2_7_8,5_4_3_9,4_5_2_4,5_0_0_2,2_9_3_0,2_1_9_3,2_9_3_0,4_3_4_1,3_2_0_8,1_0_0_5,1_0_5_5,2_1_7_1,2_8_4_8,1_1_3_0_0,3_5_3_1,1_0_2],[1_0_1,4_0_7_0,4_0_3_4,7_0_2_0,1_0_2_4,3_0_5_8,1_0_1_5,1_0_1_3,2_8_6_1,1_0_1_3,6_0_7_0,1_9_2_7_4,2_7_7_2,6_2_0_5,2_7_8_1_4,1_6_1_4_7,1_6_1_4_7,4_3_4_3,2_0_4_7,1_0_2_8_3,1_0_9_6_9,1_4_3_8_9,1_0_1_2,2_3_3_8,1_0_2]],     device=SCREAMING_SNAKE_CASE_			)  # noqa: E231
					SCREAMING_SNAKE_CASE				=	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=SCREAMING_SNAKE_CASE_			)  # noqa: E231
					SCREAMING_SNAKE_CASE				=	torch.tensor([[[0,0,0,0],[4_2_3,2_3_7,4_4_0,2_5_1],[4_2_7,2_7_2,4_4_1,2_8_7],[4_1_9,1_1_5,4_3_7,1_2_9],[9_6_1,8_8_5,9_9_2,9_1_2],[2_5_6,3_8,3_3_0,5_8],[2_5_6,3_8,3_3_0,5_8],[3_3_6,4_2,3_5_3,5_7],[3_6_0,3_9,4_0_1,5_6],[3_6_0,3_9,4_0_1,5_6],[4_1_1,3_9,4_7_1,5_9],[4_7_9,4_1,5_2_8,5_9],[5_3_3,3_9,6_3_0,6_0],[6_7,1_1_3,1_3_4,1_3_1],[1_4_1,1_1_5,2_0_9,1_3_2],[6_8,1_4_9,1_3_3,1_6_6],[1_4_1,1_4_9,1_8_7,1_6_4],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[2_9_5,1_4_8,3_4_9,1_6_5],[4_4_1,1_4_9,4_9_2,1_6_6],[4_9_7,1_4_9,5_4_6,1_6_4],[6_4,2_0_1,1_2_5,2_1_8],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]],[[0,0,0,0],[6_6_2,1_5_0,7_5_4,1_6_6],[6_6_5,1_9_9,7_4_2,2_1_1],[5_1_9,2_1_3,5_5_4,2_2_8],[5_1_9,2_1_3,5_5_4,2_2_8],[1_3_4,4_3_3,1_8_7,4_5_4],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[3_1_4,4_6_9,3_7_6,4_8_2],[5_0_4,6_8_4,5_8_2,7_0_6],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[6_1_0,7_4_9,6_5_2,7_6_5],[1_3_0,6_5_9,1_6_8,6_7_2],[1_7_6,6_5_7,2_3_7,6_7_2],[2_3_8,6_5_7,3_1_2,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[7_1_6,3_0_1,8_2_5,3_1_7],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]]],     device=SCREAMING_SNAKE_CASE_			)  # noqa: E231
					SCREAMING_SNAKE_CASE				=	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=SCREAMING_SNAKE_CASE_			)  # noqa: E231
					# these are sequence labels (i.e. at the token level)
					SCREAMING_SNAKE_CASE				=	torch.tensor([[-1_0_0,1_0,1_0,1_0,9,1,-1_0_0,7,7,-1_0_0,7,7,4,2,5,2,8,8,-1_0_0,-1_0_0,5,0,3,2,-1_0_0],[-1_0_0,1_2,1_2,1_2,-1_0_0,1_2,1_0,-1_0_0,-1_0_0,-1_0_0,-1_0_0,1_0,1_2,9,-1_0_0,-1_0_0,-1_0_0,1_0,1_0,1_0,9,1_2,-1_0_0,1_0,-1_0_0]],     device=SCREAMING_SNAKE_CASE_			)  # noqa: E231
					# fmt: on

					return input_ids, attention_mask, bbox, token_type_ids, labels




@require_torch
class      UpperCamelCase	(       unittest.TestCase      ):

				"""simple docstring"""



				@slow
				def 							A					(				self			)    ->    str:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	LayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased'			).to(lowercase__			)

									SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE				=	prepare_layoutlm_batch_inputs()

									# forward pass
									SCREAMING_SNAKE_CASE				=	model(input_ids=lowercase__		,	bbox=lowercase__		,	attention_mask=lowercase__		,	token_type_ids=lowercase__			)

									# test the sequence output on [0, :3, :3]
									SCREAMING_SNAKE_CASE				=	torch.tensor(
									    [[0.1_785, -0.1_947, -0.0_425], [-0.3_254, -0.2_807, 0.2_553], [-0.5_391, -0.3_322, 0.3_364]]		,	device=lowercase__		,	)

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

									# test the pooled output on [1, :3]
									SCREAMING_SNAKE_CASE				=	torch.tensor([-0.6_580, -0.0_214, 0.8_552]		,	device=lowercase__			)

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


				@slow
				def 							A					(				self			)    ->    Tuple:
									"""simple docstring"""







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

									SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE				=	prepare_layoutlm_batch_inputs()

									# forward pass
									SCREAMING_SNAKE_CASE				=	model(
									    input_ids=lowercase__		,	bbox=lowercase__		,	attention_mask=lowercase__		,	token_type_ids=lowercase__		,	labels=torch.tensor([1, 1]		,	device=lowercase__			)		,	)

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

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


				@slow
				def 							A					(				self			)    ->    Tuple:
									"""simple docstring"""







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

									SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE				=	prepare_layoutlm_batch_inputs()

									# forward pass
									SCREAMING_SNAKE_CASE				=	model(
									    input_ids=lowercase__		,	bbox=lowercase__		,	attention_mask=lowercase__		,	token_type_ids=lowercase__		,	labels=lowercase__			)

									# 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
									SCREAMING_SNAKE_CASE				=	outputs.logits
									SCREAMING_SNAKE_CASE				=	torch.Size((2, 25, 13)			)
									self.assertEqual(logits.shape		,	lowercase__			)




				@slow
				def 							A					(				self			)    ->    Dict:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	LayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased'			).to(lowercase__			)

									SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE				=	prepare_layoutlm_batch_inputs()

									# forward pass
									SCREAMING_SNAKE_CASE				=	model(input_ids=lowercase__		,	bbox=lowercase__		,	attention_mask=lowercase__		,	token_type_ids=lowercase__			)

									# test the shape of the logits
									SCREAMING_SNAKE_CASE				=	torch.Size((2, 25)			)
									self.assertEqual(outputs.start_logits.shape		,	lowercase__			)
									self.assertEqual(outputs.end_logits.shape		,	lowercase__			)


"""simple docstring"""




import unittest

from transformers.testing_utils import is_torch_available, require_torch, tooslow

from ...generation.test_utils import 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 (
	    CpmAntConfig,
	    CpmAntForCausalLM,
	    CpmAntModel,
	    CpmAntTokenizer,
	)




@require_torch
class      UpperCamelCase	:

				"""simple docstring"""



				def __init__(				self		,	lowercase__		,	lowercase__=2		,	lowercase__=8		,	lowercase__=True		,	lowercase__=False		,	lowercase__=False		,	lowercase__=False		,	lowercase__=False		,	lowercase__=99		,	lowercase__=32		,	lowercase__=3		,	lowercase__=4		,	lowercase__=37		,	lowercase__=32		,	lowercase__=128		,	lowercase__=8		,	lowercase__=8		,	lowercase__=8		,	lowercase__=1.0		,	lowercase__=True		,	)    ->    str:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	parent
									SCREAMING_SNAKE_CASE				=	batch_size
									SCREAMING_SNAKE_CASE				=	seq_length
									SCREAMING_SNAKE_CASE				=	is_training
									SCREAMING_SNAKE_CASE				=	use_token_type_ids
									SCREAMING_SNAKE_CASE				=	use_input_mask
									SCREAMING_SNAKE_CASE				=	use_labels
									SCREAMING_SNAKE_CASE				=	use_mc_token_ids
									SCREAMING_SNAKE_CASE				=	vocab_size
									SCREAMING_SNAKE_CASE				=	hidden_size
									SCREAMING_SNAKE_CASE				=	num_hidden_layers
									SCREAMING_SNAKE_CASE				=	num_attention_heads
									SCREAMING_SNAKE_CASE				=	intermediate_size
									SCREAMING_SNAKE_CASE				=	num_buckets
									SCREAMING_SNAKE_CASE				=	max_distance
									SCREAMING_SNAKE_CASE				=	prompt_length
									SCREAMING_SNAKE_CASE				=	prompt_types
									SCREAMING_SNAKE_CASE				=	segment_types
									SCREAMING_SNAKE_CASE				=	init_std
									SCREAMING_SNAKE_CASE				=	return_dict


				def 							A					(				self			)    ->    Tuple:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	{}
									SCREAMING_SNAKE_CASE				=	ids_tensor([self.batch_size, self.seq_length]		,	self.vocab_size			).type(torch.intaa			)
									SCREAMING_SNAKE_CASE				=	False

									SCREAMING_SNAKE_CASE				=	self.get_config()

									return (config, input_ids)


				def 							A					(				self			)    ->    List[Any]:
									"""simple docstring"""







									return CpmAntConfig(
									    vocab_size=self.vocab_size		,	hidden_size=self.hidden_size		,	num_hidden_layers=self.num_hidden_layers		,	num_attention_heads=self.num_attention_heads		,	dim_ff=self.intermediate_size		,	position_bias_num_buckets=self.num_buckets		,	position_bias_max_distance=self.max_distance		,	prompt_types=self.prompt_types		,	prompt_length=self.prompt_length		,	segment_types=self.segment_types		,	use_cache=lowercase__		,	init_std=self.init_std		,	return_dict=self.return_dict		,	)


				def 							A					(				self		,	lowercase__		,	lowercase__		,	*lowercase__			)    ->    Union[str, Any]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	CpmAntModel(config=lowercase__			)
									model.to(lowercase__			)
									model.eval()

									SCREAMING_SNAKE_CASE				=	model(**lowercase__			).last_hidden_state

									self.parent.assertEqual(hidden_states.shape		,	(self.batch_size, self.seq_length, config.hidden_size)			)


				def 							A					(				self		,	lowercase__		,	lowercase__		,	*lowercase__			)    ->    int:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	CpmAntForCausalLM(lowercase__			)
									model.to(lowercase__			)
									SCREAMING_SNAKE_CASE				=	input_ids['input_ids'].to(lowercase__			)
									model.eval()

									SCREAMING_SNAKE_CASE				=	model(**lowercase__			)
									self.parent.assertEqual(
									    model_output.logits.shape		,	(self.batch_size, self.seq_length, config.vocab_size + config.prompt_types * config.prompt_length)		,	)




				def 							A					(				self			)    ->    Optional[Any]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE				=	self.prepare_config_and_inputs()
									return config, inputs_dict






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

				"""simple docstring"""



				UpperCAmelCase_				:      List[str]						  =				(CpmAntModel, CpmAntForCausalLM) if is_torch_available() else ()
				UpperCAmelCase_				:      List[Any]						  =				(
				    {"feature-extraction": CpmAntModel, "text-generation": CpmAntForCausalLM} if is_torch_available() else {}
				)

				UpperCAmelCase_				:      List[Any]						  =				False
				UpperCAmelCase_				:      Optional[int]						  =				False
				UpperCAmelCase_				:      Optional[Any]						  =				False
				UpperCAmelCase_				:      List[str]						  =				False
				UpperCAmelCase_				:      Dict						  =				False


				def 							A					(				self			)    ->    Union[str, Any]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	CpmAntModelTester(self			)
									SCREAMING_SNAKE_CASE				=	ConfigTester(self		,	config_class=lowercase__			)


				def 							A					(				self			)    ->    Tuple:
									"""simple docstring"""







									self.config_tester.create_and_test_config_common_properties()
									self.config_tester.create_and_test_config_to_json_string()
									self.config_tester.create_and_test_config_to_json_file()
									self.config_tester.create_and_test_config_from_and_save_pretrained()
									self.config_tester.check_config_can_be_init_without_params()
									self.config_tester.check_config_arguments_init()


				def 							A					(				self			)    ->    List[str]:
									"""simple docstring"""







									unittest.skip('CPMAnt doesn\'t support input_embeds.'			)(self.test_inputs_embeds			)


				def 							A					(				self			)    ->    Optional[int]:
									"""simple docstring"""







									unittest.skip(
									    'CPMAnt doesn\'t support retain grad in hidden_states or attentions, because prompt management will peel off the output.hidden_states from graph.\
                 So is attentions. We strongly recommand you use loss to tune model.'			)(self.test_retain_grad_hidden_states_attentions			)


				def 							A					(				self			)    ->    List[str]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE				=	self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_cpmant_model(lowercase__		,	lowercase__			)




				def 							A					(				self			)    ->    str:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE				=	self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_lm_head_model(lowercase__		,	lowercase__			)






@require_torch
class      UpperCamelCase	(       unittest.TestCase      ):

				"""simple docstring"""



				@tooslow
				def 							A					(				self			)    ->    Any:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	'今天天气真好！'
									SCREAMING_SNAKE_CASE				=	'openbmb/cpm-ant-10b'
									SCREAMING_SNAKE_CASE				=	CpmAntModel.from_pretrained(lowercase__			)
									SCREAMING_SNAKE_CASE				=	CpmAntTokenizer.from_pretrained(lowercase__			)
									SCREAMING_SNAKE_CASE				=	tokenizer(lowercase__		,	return_tensors='pt'			)
									SCREAMING_SNAKE_CASE				=	model(**lowercase__			).last_hidden_state

									SCREAMING_SNAKE_CASE				=	torch.tensor(
									    [[[6.1_708, 5.9_244, 1.0_835], [6.5_207, 6.2_893, -11.3_324], [-1.0_107, -0.0_576, -5.9_577]]]		,	)
									self.assertTrue(torch.allclose(hidden_states[:, :3, :3]		,	lowercase__		,	atol=1E-2			)			)






@require_torch
class      UpperCamelCase	(       unittest.TestCase      ):

				"""simple docstring"""



				@tooslow
				def 							A					(				self			)    ->    str:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	'今天天气真好！'
									SCREAMING_SNAKE_CASE				=	'openbmb/cpm-ant-10b'
									SCREAMING_SNAKE_CASE				=	CpmAntForCausalLM.from_pretrained(lowercase__			)
									SCREAMING_SNAKE_CASE				=	CpmAntTokenizer.from_pretrained(lowercase__			)
									SCREAMING_SNAKE_CASE				=	tokenizer(lowercase__		,	return_tensors='pt'			)
									SCREAMING_SNAKE_CASE				=	model(**lowercase__			).logits

									SCREAMING_SNAKE_CASE				=	torch.tensor(
									    [[[-6.4_267, -6.4_083, -6.3_958], [-5.8_802, -5.9_447, -5.7_811], [-5.3_896, -5.4_820, -5.4_295]]]		,	)
									self.assertTrue(torch.allclose(hidden_states[:, :3, :3]		,	lowercase__		,	atol=1E-2			)			)


				@tooslow
				def 							A					(				self			)    ->    Optional[Any]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	'openbmb/cpm-ant-10b'
									SCREAMING_SNAKE_CASE				=	CpmAntForCausalLM.from_pretrained(lowercase__			)
									SCREAMING_SNAKE_CASE				=	CpmAntTokenizer.from_pretrained(lowercase__			)
									SCREAMING_SNAKE_CASE				=	'今天天气不错，'
									SCREAMING_SNAKE_CASE				=	'今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的'
									SCREAMING_SNAKE_CASE				=	tokenizer(lowercase__		,	return_tensors='pt'			)
									SCREAMING_SNAKE_CASE				=	model.generate(**lowercase__			)
									SCREAMING_SNAKE_CASE				=	tokenizer.batch_decode(lowercase__			)
									self.assertEqual(lowercase__		,	lowercase__			)




				@tooslow
				def 							A					(				self			)    ->    str:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	'openbmb/cpm-ant-10b'
									SCREAMING_SNAKE_CASE				=	CpmAntForCausalLM.from_pretrained(lowercase__			)
									SCREAMING_SNAKE_CASE				=	CpmAntTokenizer.from_pretrained(lowercase__			)
									SCREAMING_SNAKE_CASE				=	['今天天气不错，', '新年快乐，万事如意！']
									SCREAMING_SNAKE_CASE				=	[
									    '今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的',
									    '新年快乐，万事如意！在这辞旧迎新的美好时刻，我谨代表《农村新技术》杂志社全体同仁，向一直以来关心、支持《农村新技术》杂志发展的各级领导、各界朋友和广大读者致以最诚挚的',
									]
									SCREAMING_SNAKE_CASE				=	tokenizer(lowercase__		,	return_tensors='pt'		,	padding=lowercase__			)
									SCREAMING_SNAKE_CASE				=	model.generate(**lowercase__			)
									SCREAMING_SNAKE_CASE				=	tokenizer.batch_decode(lowercase__			)
									self.assertEqual(lowercase__		,	lowercase__			)
