




'''simple docstring'''





import pickle

import numpy as np
from matplotlib import pyplot as plt




class 			_snake_case		:




			def __init__( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__=0.2    ,							a__=0.2							)    ->    Optional[Any]:

										'''simple docstring'''




										snake_case_      =				bp_numa
										snake_case_      =				bp_numa
										snake_case_      =				bp_numa
										snake_case_      =				conva_get[:2]
										snake_case_      =				conva_get[2]
										snake_case_      =				size_pa
										snake_case_      =				rate_w
										snake_case_      =				rate_t
										snake_case_      =				[
										    np.mat(-1 * np.random.rand(self.conva[0]    ,							self.conva[0]							) + 0.5							)
										    for i in range(self.conva[1]							)
										]
										snake_case_      =				np.mat(-1 * np.random.rand(self.num_bpa    ,							self.num_bpa							) + 0.5							)
										snake_case_      =				np.mat(-1 * np.random.rand(self.num_bpa    ,							self.num_bpa							) + 0.5							)
										snake_case_      =				-2 * np.random.rand(self.conva[1]							) + 1
										snake_case_      =				-2 * np.random.rand(self.num_bpa							) + 1
										snake_case_      =				-2 * np.random.rand(self.num_bpa							) + 1




			def        lowerCAmelCase__    ( self    ,							a__							)    ->    Optional[Any]:

										'''simple docstring'''




										snake_case_      =				{
										    "num_bp1": self.num_bpa,
										    "num_bp2": self.num_bpa,
										    "num_bp3": self.num_bpa,
										    "conv1": self.conva,
										    "step_conv1": self.step_conva,
										    "size_pooling1": self.size_poolinga,
										    "rate_weight": self.rate_weight,
										    "rate_thre": self.rate_thre,
										    "w_conv1": self.w_conva,
										    "wkj": self.wkj,
										    "vji": self.vji,
										    "thre_conv1": self.thre_conva,
										    "thre_bp2": self.thre_bpa,
										    "thre_bp3": self.thre_bpa,
										}
										with open(a__    ,							"wb"							) as f:
																	pickle.dump(a__    ,							a__							)

										print(F'Model saved： {save_path}'							)




			@classmethod
			def        lowerCAmelCase__    ( cls    ,							a__							)    ->    List[str]:

										'''simple docstring'''




										with open(a__    ,							"rb"							) as f:
																	snake_case_      =				pickle.load(a__							)  # noqa: S301

										snake_case_      =				model_dic.get("conv1"							)
										conv_get.append(model_dic.get("step_conv1"							)							)
										snake_case_      =				model_dic.get("size_pooling1"							)
										snake_case_      =				model_dic.get("num_bp1"							)
										snake_case_      =				model_dic.get("num_bp2"							)
										snake_case_      =				model_dic.get("num_bp3"							)
										snake_case_      =				model_dic.get("rate_weight"							)
										snake_case_      =				model_dic.get("rate_thre"							)
										# create model instance
										snake_case_      =				CNN(a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)
										# modify model parameter
										snake_case_      =				model_dic.get("w_conv1"							)
										snake_case_      =				model_dic.get("wkj"							)
										snake_case_      =				model_dic.get("vji"							)
										snake_case_      =				model_dic.get("thre_conv1"							)
										snake_case_      =				model_dic.get("thre_bp2"							)
										snake_case_      =				model_dic.get("thre_bp3"							)
										return conv_ins




			def        lowerCAmelCase__    ( self    ,							a__							)    ->    Optional[Any]:

										'''simple docstring'''




										return 1 / (1 + np.exp(-1 * x							))




			def        lowerCAmelCase__    ( self    ,							a__							)    ->    Tuple:

										'''simple docstring'''




										return round(a__    ,							3							)




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    Tuple:

										'''simple docstring'''




										snake_case_      =				convs[0]
										snake_case_      =				convs[1]
										snake_case_      =				np.shape(a__							)[0]
										# get the data slice of original image data, data_focus
										snake_case_      =				[]
										for i_focus in range(0    ,							size_data - size_conv + 1    ,							a__							):
																	for j_focus in range(0    ,							size_data - size_conv + 1    ,							a__							):
																								snake_case_      =				data[
																								    i_focus : i_focus + size_conv, j_focus : j_focus + size_conv
																								]
																								data_focus.append(a__							)
        # calculate the feature map of every single kernel, and saved as list of matrix
										snake_case_      =				[]
										snake_case_      =				int((size_data - size_conv) / conv_step + 1							)
										for i_map in range(a__							):
																	snake_case_      =				[]
																	for i_focus in range(len(a__							)							):
																								snake_case_      =				(
																								    np.sum(np.multiply(data_focus[i_focus]    ,							w_convs[i_map]							)							)
																								    - thre_convs[i_map]
																								)
																								featuremap.append(self.sig(a__							)							)
																	snake_case_      =				np.asmatrix(a__							).reshape(
																	    a__    ,							a__							)
																	data_featuremap.append(a__							)

										# expanding the data slice to One dimenssion
										snake_case_      =				[]
										for each_focus in data_focus:
																	focusa_list.extend(self.Expand_Mat(a__							)							)
										snake_case_      =				np.asarray(a__							)
										return focus_list, data_featuremap




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__="average_pool"							)    ->    Tuple:

										'''simple docstring'''




										snake_case_      =				len(featuremaps[0]							)
										snake_case_      =				int(size_map / size_pooling							)
										snake_case_      =				[]
										for i_map in range(len(a__							)							):
																	snake_case_      =				featuremaps[i_map]
																	snake_case_      =				[]
																	for i_focus in range(0    ,							a__    ,							a__							):
																								for j_focus in range(0    ,							a__    ,							a__							):
																															snake_case_      =				feature_map[
																															    i_focus : i_focus + size_pooling,
																															    j_focus : j_focus + size_pooling,
																															]
																															if pooling_type == "average_pool":
																																						# average pooling
																																						map_pooled.append(np.average(a__							)							)
																															elif pooling_type == "max_pooling":
																																						# max pooling
																																						map_pooled.append(np.max(a__							)							)
																	snake_case_      =				np.asmatrix(a__							).reshape(a__    ,							a__							)
																	featuremap_pooled.append(a__							)
										return featuremap_pooled




			def        lowerCAmelCase__    ( self    ,							a__							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				[]
										for i in range(len(a__							)							):
																	snake_case_      =				np.shape(data[i]							)
																	snake_case_      =				data[i].reshape(1    ,							shapes[0] * shapes[1]							)
																	snake_case_      =				data_listed.getA().tolist()[0]
																	data_expanded.extend(a__							)
										snake_case_      =				np.asarray(a__							)
										return data_expanded




			def        lowerCAmelCase__    ( self    ,							a__							)    ->    Any:

										'''simple docstring'''




										snake_case_      =				np.asarray(a__							)
										snake_case_      =				np.shape(a__							)
										snake_case_      =				data_mat.reshape(1    ,							shapes[0] * shapes[1]							)
										return data_expanded




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    Optional[Any]:

										'''simple docstring'''




										snake_case_      =				[]
										snake_case_      =				0
										for i_map in range(a__							):
																	snake_case_      =				np.ones((size_map, size_map)							)
																	for i in range(0    ,							a__    ,							a__							):
																								for j in range(0    ,							a__    ,							a__							):
																															snake_case_      =				pd_pool[
																															    i_pool
																															]
																															snake_case_      =				i_pool + 1
																	snake_case_      =				np.multiply(
																	    a__    ,							np.multiply(out_map[i_map]    ,							(1 - out_map[i_map])							)							)
																	pd_all.append(a__							)
										return pd_all




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__=bool							)    ->    Optional[int]:

										'''simple docstring'''




										print("----------------------Start Training-------------------------"							)
										print((" - - Shape: Train_Data  ", np.shape(a__							))							)
										print((" - - Shape: Teach_Data  ", np.shape(a__							))							)
										snake_case_      =				0
										snake_case_      =				[]
										snake_case_      =				10_000
										while rp < n_repeat and mse >= error_accuracy:
																	snake_case_      =				0
																	print(F'-------------Learning Time {rp}--------------'							)
																	for p in range(len(a__							)							):
																								# print('------------Learning Image: %d--------------'%p)
																								snake_case_      =				np.asmatrix(datas_train[p]							)
																								snake_case_      =				np.asarray(datas_teach[p]							)
																								snake_case_ ,				snake_case_      =				self.convolute(
																								    a__    ,							self.conva    ,							self.w_conva    ,							self.thre_conva    ,							conv_step=self.step_conva    ,							)
																								snake_case_      =				self.pooling(a__    ,							self.size_poolinga							)
																								snake_case_      =				np.shape(a__							)
																								snake_case_      =				self._expand(a__							)
																								snake_case_      =				data_bp_input

																								snake_case_      =				np.dot(a__    ,							self.vji.T							) - self.thre_bpa
																								snake_case_      =				self.sig(a__							)
																								snake_case_      =				np.dot(a__    ,							self.wkj.T							) - self.thre_bpa
																								snake_case_      =				self.sig(a__							)

																								# --------------Model Leaning ------------------------
																								# calculate error and gradient---------------
																								snake_case_      =				np.multiply(
																								    (data_teach - bp_outa)    ,							np.multiply(a__    ,							(1 - bp_outa)							)							)
																								snake_case_      =				np.multiply(
																								    np.dot(a__    ,							self.wkj							)    ,							np.multiply(a__    ,							(1 - bp_outa)							)							)
																								snake_case_      =				np.dot(a__    ,							self.vji							)

																								snake_case_      =				pd_i_all / (self.size_poolinga * self.size_poolinga)
																								snake_case_      =				pd_conva_pooled.T.getA().tolist()
																								snake_case_      =				self._calculate_gradient_from_pool(
																								    a__    ,							a__    ,							shape_featuremapa[0]    ,							shape_featuremapa[1]    ,							self.size_poolinga    ,							)
																								# weight and threshold learning process---------
																								# convolution layer
																								for k_conv in range(self.conva[1]							):
																															snake_case_      =				self._expand_mat(pd_conva_all[k_conv]							)
																															snake_case_      =				self.rate_weight * np.dot(a__    ,							a__							)

																															snake_case_      =				self.w_conva[k_conv] + delta_w.reshape(
																															    (self.conva[0], self.conva[0])							)

																															snake_case_      =				(
																															    self.thre_conva[k_conv]
																															    - np.sum(pd_conva_all[k_conv]							) * self.rate_thre
																															)
																								# all connected layer
																								snake_case_      =				self.wkj + pd_k_all.T * bp_outa * self.rate_weight
																								snake_case_      =				self.vji + pd_j_all.T * bp_outa * self.rate_weight
																								snake_case_      =				self.thre_bpa - pd_k_all * self.rate_thre
																								snake_case_      =				self.thre_bpa - pd_j_all * self.rate_thre
																								# calculate the sum error of all single image
																								snake_case_      =				np.sum(abs(data_teach - bp_outa							)							)
																								error_count += errors
																								# print('   ----Teach      ',data_teach)
																								# print('   ----BP_output  ',bp_out3)
																	snake_case_      =				rp + 1
																	snake_case_      =				error_count / patterns
																	all_mse.append(a__							)

										def draw_error():
																	snake_case_      =				[error_accuracy for i in range(int(n_repeat * 1.2							)							)]
																	plt.plot(a__    ,							"+-"							)
																	plt.plot(a__    ,							"r--"							)
																	plt.xlabel("Learning Times"							)
																	plt.ylabel("All_mse"							)
																	plt.grid(a__    ,							alpha=0.5							)
																	plt.show()

										print("------------------Training Complished---------------------"							)
										print((" - - Training epoch: ", rp, F'     - - Mse: {mse:.6f}')							)
										if draw_e:
																	draw_error()
										return mse




			def        lowerCAmelCase__    ( self    ,							a__							)    ->    List[Any]:

										'''simple docstring'''




										snake_case_      =				[]
										print("-------------------Start Testing-------------------------"							)
										print((" - - Shape: Test_Data  ", np.shape(a__							))							)
										for p in range(len(a__							)							):
																	snake_case_      =				np.asmatrix(datas_test[p]							)
																	snake_case_ ,				snake_case_      =				self.convolute(
																	    a__    ,							self.conva    ,							self.w_conva    ,							self.thre_conva    ,							conv_step=self.step_conva    ,							)
																	snake_case_      =				self.pooling(a__    ,							self.size_poolinga							)
																	snake_case_      =				self._expand(a__							)

																	snake_case_      =				data_bp_input
																	snake_case_      =				bp_outa * self.vji.T - self.thre_bpa
																	snake_case_      =				self.sig(a__							)
																	snake_case_      =				bp_outa * self.wkj.T - self.thre_bpa
																	snake_case_      =				self.sig(a__							)
																	produce_out.extend(bp_outa.getA().tolist()							)
										snake_case_      =				[list(map(self.do_round    ,							a__							)							) for each in produce_out]
										return np.asarray(a__							)




			def        lowerCAmelCase__    ( self    ,							a__							)    ->    str:

										'''simple docstring'''




										snake_case_      =				np.asmatrix(a__							)
										snake_case_ ,				snake_case_      =				self.convolute(
										    a__    ,							self.conva    ,							self.w_conva    ,							self.thre_conva    ,							conv_step=self.step_conva    ,							)
										snake_case_      =				self.pooling(a__    ,							self.size_poolinga							)

										return data_conveda, data_pooleda


if __name__ == "__main__":
		pass










'''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 			_snake_case		:




			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__=512    ,							a__=16    ,							a__=2    ,							a__=0.0_2    ,							a__=3    ,							a__=4    ,							a__=None    ,							a__=1_000    ,							)    ->    Optional[int]:

										'''simple docstring'''




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




			def        lowerCAmelCase__    ( self							)    ->    List[Any]:

										'''simple docstring'''




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

										# convert bbox to numpy since TF does not support item assignment
										snake_case_      =				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]:
																															snake_case_      =				bbox[i, j, 3]
																															snake_case_      =				bbox[i, j, 1]
																															snake_case_      =				t
																								if bbox[i, j, 2] < bbox[i, j, 0]:
																															snake_case_      =				bbox[i, j, 2]
																															snake_case_      =				bbox[i, j, 0]
																															snake_case_      =				t
										snake_case_      =				tf.convert_to_tensor(a__							)

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

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

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

										snake_case_      =				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        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    Optional[Any]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMModel(config=a__							)

										snake_case_      =				model(a__    ,							a__    ,							attention_mask=a__    ,							token_type_ids=a__							)
										snake_case_      =				model(a__    ,							a__    ,							token_type_ids=a__							)
										snake_case_      =				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    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForMaskedLM(config=a__							)

										snake_case_      =				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    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				self.num_labels
										snake_case_      =				TFLayoutLMForSequenceClassification(config=a__							)

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




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    List[str]:

										'''simple docstring'''




										snake_case_      =				self.num_labels
										snake_case_      =				TFLayoutLMForTokenClassification(config=a__							)

										snake_case_      =				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    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForQuestionAnswering(config=a__							)

										snake_case_      =				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        lowerCAmelCase__    ( self							)    ->    Optional[int]:

										'''simple docstring'''




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




@require_tf
class 			_snake_case		(     lowercase_						,						lowercase_						,						unittest.TestCase							):
			lowerCAmelCase_					:				Optional[int]							=   (
			    (
			        TFLayoutLMModel,
			        TFLayoutLMForMaskedLM,
			        TFLayoutLMForTokenClassification,
			        TFLayoutLMForSequenceClassification,
			        TFLayoutLMForQuestionAnswering,
			    )
			    if is_tf_available()
			    else ()
			)
			lowerCAmelCase_					:				List[Any]							=   (
			    {
			        "feature-extraction": TFLayoutLMModel,
			        "fill-mask": TFLayoutLMForMaskedLM,
			        "text-classification": TFLayoutLMForSequenceClassification,
			        "token-classification": TFLayoutLMForTokenClassification,
			        "zero-shot": TFLayoutLMForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			lowerCAmelCase_					:				Union[str, Any]							=   False
			lowerCAmelCase_					:				int							=   True
			lowerCAmelCase_					:				List[str]							=   10




			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMModelTester(self							)
										snake_case_      =				ConfigTester(self    ,							config_class=a__    ,							hidden_size=37							)




			def        lowerCAmelCase__    ( self							)    ->    List[Any]:

										'''simple docstring'''




										self.config_tester.run_common_tests()




			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*a__							)




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

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*a__							)




			def        lowerCAmelCase__    ( self							)    ->    Dict:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*a__							)




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

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*a__							)




			def        lowerCAmelCase__    ( self							)    ->    Tuple:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*a__							)




			@slow
			def        lowerCAmelCase__    ( self							)    ->    Dict:

										'''simple docstring'''




										for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	snake_case_      =				TFLayoutLMModel.from_pretrained(a__							)
																	self.assertIsNotNone(a__							)




			@unittest.skip("Onnx compliancy broke with TF 2.10"							)
			def        lowerCAmelCase__    ( self							)    ->    Union[str, Any]:

										'''simple docstring'''




										pass


def 					UpperCamelCase_(     ):

							'''simple docstring'''






							snake_case_      =				tf.convert_to_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]]					)  # noqa: E231
							snake_case_      =				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
							snake_case_      =				tf.convert_to_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]]]					)  # noqa: E231
							snake_case_      =				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)
							snake_case_      =				tf.convert_to_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]]					)  # noqa: E231
							# fmt: on

							return input_ids, attention_mask, bbox, token_type_ids, labels




@require_tf
class 			_snake_case		(     unittest.TestCase							):




			@slow
			def        lowerCAmelCase__    ( self							)    ->    int:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"							)

										snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      =				prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_      =				model(input_ids=a__    ,							bbox=a__    ,							attention_mask=a__    ,							token_type_ids=a__							)

										# test the sequence output on [0, :3, :3]
										snake_case_      =				tf.convert_to_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]]    ,							)

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

										# test the pooled output on [1, :3]
										snake_case_      =				tf.convert_to_tensor([-0.6_5_8_0, -0.0_2_1_4, 0.8_5_5_2]							)

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




			@slow
			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased"    ,							num_labels=2							)

										snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      =				prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_      =				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
										snake_case_      =				outputs.loss
										snake_case_      =				(2,)
										self.assertEqual(loss.shape    ,							a__							)

										# test the shape of the logits
										snake_case_      =				outputs.logits
										snake_case_      =				(2, 2)
										self.assertEqual(logits.shape    ,							a__							)




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

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased"    ,							num_labels=13							)

										snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      =				prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_      =				model(
										    input_ids=a__    ,							bbox=a__    ,							attention_mask=a__    ,							token_type_ids=a__    ,							labels=a__							)

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




			@slow
			def        lowerCAmelCase__    ( self							)    ->    List[Any]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"							)

										snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      =				prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_      =				model(input_ids=a__    ,							bbox=a__    ,							attention_mask=a__    ,							token_type_ids=a__							)

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




