






"""simple docstring"""





from __future__ import annotations

import unittest
from collections.abc import Iterator







class 		_a       :





			'''simple docstring'''






			def __init__(   self			,				UpperCAmelCase_			,				UpperCAmelCase_)	-> None:




										'''simple docstring'''




										lowercase__:    Dict        =      label
										lowercase__:    List[Any]        =      parent
										lowercase__:    Node | None        =      None
										lowercase__:    Node | None        =      None







class 		_a       :





			'''simple docstring'''






			def __init__(   self)	-> None:




										'''simple docstring'''




										lowercase__:    Node | None        =      None





			def __lowercase    (   self)	-> None:




										'''simple docstring'''




										lowercase__:    List[str]        =      None





			def __lowercase    (   self)	-> bool:




										'''simple docstring'''




										return self.root is None





			def __lowercase    (   self			,				UpperCAmelCase_)	-> None:




										'''simple docstring'''




										lowercase__:    List[str]        =      self._put(self.root			,				UpperCAmelCase_)





			def __lowercase    (   self			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_ = None)	-> Node:




										'''simple docstring'''




										if node is None:
																	lowercase__:    List[Any]        =      Node(UpperCAmelCase_			,				UpperCAmelCase_)
										else:
																	if label < node.label:
																								lowercase__:    str        =      self._put(node.left			,				UpperCAmelCase_			,				UpperCAmelCase_)
																	elif label > node.label:
																								lowercase__:    int        =      self._put(node.right			,				UpperCAmelCase_			,				UpperCAmelCase_)
																	else:
																								lowercase__:    List[Any]        =      F"""Node with label {label} already exists"""
																								raise Exception(UpperCAmelCase_)

										return node





			def __lowercase    (   self			,				UpperCAmelCase_)	-> Node:




										'''simple docstring'''




										return self._search(self.root			,				UpperCAmelCase_)





			def __lowercase    (   self			,				UpperCAmelCase_			,				UpperCAmelCase_)	-> Node:




										'''simple docstring'''




										if node is None:
																	lowercase__:    int        =      F"""Node with label {label} does not exist"""
																	raise Exception(UpperCAmelCase_)
										else:
																	if label < node.label:
																								lowercase__:    str        =      self._search(node.left			,				UpperCAmelCase_)
																	elif label > node.label:
																								lowercase__:    List[str]        =      self._search(node.right			,				UpperCAmelCase_)

										return node





			def __lowercase    (   self			,				UpperCAmelCase_)	-> None:




										'''simple docstring'''




										lowercase__:    Optional[Any]        =      self.search(UpperCAmelCase_)
										if node.right and node.left:
																	lowercase__:    List[str]        =      self._get_lowest_node(node.right)
																	lowercase__:    Any        =      node.left
																	lowercase__:    Any        =      node.right
																	lowercase__:    Dict        =      lowest_node
																	if node.right:
																								lowercase__:    List[str]        =      lowest_node
																	self._reassign_nodes(UpperCAmelCase_			,				UpperCAmelCase_)
										elif not node.right and node.left:
																	self._reassign_nodes(UpperCAmelCase_			,				node.left)
										elif node.right and not node.left:
																	self._reassign_nodes(UpperCAmelCase_			,				node.right)
										else:
																	self._reassign_nodes(UpperCAmelCase_			,				UpperCAmelCase_)





			def __lowercase    (   self			,				UpperCAmelCase_			,				UpperCAmelCase_)	-> None:




										'''simple docstring'''




										if new_children:
																	lowercase__:    Union[str, Any]        =      node.parent

										if node.parent:
																	if node.parent.right == node:
																								lowercase__:    str        =      new_children
																	else:
																								lowercase__:    Union[str, Any]        =      new_children
										else:
																	lowercase__:    Tuple        =      new_children





			def __lowercase    (   self			,				UpperCAmelCase_)	-> Node:




										'''simple docstring'''




										if node.left:
																	lowercase__:    int        =      self._get_lowest_node(node.left)
										else:
																	lowercase__:    List[str]        =      node
																	self._reassign_nodes(UpperCAmelCase_			,				node.right)

										return lowest_node





			def __lowercase    (   self			,				UpperCAmelCase_)	-> bool:




										'''simple docstring'''




										try:
																	self.search(UpperCAmelCase_)
																	return True
										except Exception:
																	return False





			def __lowercase    (   self)	-> int:




										'''simple docstring'''




										if self.root is None:
																	raise Exception("Binary search tree is empty")

										lowercase__:    str        =      self.root
										while node.right is not None:
																	lowercase__:    Optional[Any]        =      node.right

										return node.label





			def __lowercase    (   self)	-> int:




										'''simple docstring'''




										if self.root is None:
																	raise Exception("Binary search tree is empty")

										lowercase__:    Tuple        =      self.root
										while node.left is not None:
																	lowercase__:    int        =      node.left

										return node.label





			def __lowercase    (   self)	-> Iterator[Node]:




										'''simple docstring'''




										return self._inorder_traversal(self.root)





			def __lowercase    (   self			,				UpperCAmelCase_)	-> Iterator[Node]:




										'''simple docstring'''




										if node is not None:
																	yield from self._inorder_traversal(node.left)
																	yield node
																	yield from self._inorder_traversal(node.right)





			def __lowercase    (   self)	-> Iterator[Node]:




										'''simple docstring'''




										return self._preorder_traversal(self.root)





			def __lowercase    (   self			,				UpperCAmelCase_)	-> Iterator[Node]:




										'''simple docstring'''




										if node is not None:
																	yield node
																	yield from self._preorder_traversal(node.left)
																	yield from self._preorder_traversal(node.right)







class 		_a       (						unittest.TestCase   ):





			'''simple docstring'''






			@staticmethod
			def __lowercase    (   )	-> BinarySearchTree:




										'''simple docstring'''




										lowercase__:    Optional[Any]        =      BinarySearchTree()
										t.put(8)
										t.put(3)
										t.put(6)
										t.put(1)
										t.put(10)
										t.put(14)
										t.put(13)
										t.put(4)
										t.put(7)
										t.put(5)

										return t





			def __lowercase    (   self)	-> None:




										'''simple docstring'''




										lowercase__:    int        =      BinarySearchTree()
										assert t.is_empty()

										t.put(8)
										assert t.root is not None
										assert t.root.parent is None
										assert t.root.label == 8

										t.put(10)
										assert t.root.right is not None
										assert t.root.right.parent == t.root
										assert t.root.right.label == 10

										t.put(3)
										assert t.root.left is not None
										assert t.root.left.parent == t.root
										assert t.root.left.label == 3

										t.put(6)
										assert t.root.left.right is not None
										assert t.root.left.right.parent == t.root.left
										assert t.root.left.right.label == 6

										t.put(1)
										assert t.root.left.left is not None
										assert t.root.left.left.parent == t.root.left
										assert t.root.left.left.label == 1

										with self.assertRaises(UpperCAmelCase_):  # noqa: B017
																	t.put(1)





			def __lowercase    (   self)	-> None:




										'''simple docstring'''




										lowercase__:    Optional[int]        =      self._get_binary_search_tree()

										lowercase__:    Tuple        =      t.search(6)
										assert node.label == 6

										lowercase__:    List[str]        =      t.search(13)
										assert node.label == 13

										with self.assertRaises(UpperCAmelCase_):  # noqa: B017
																	t.search(2)





			def __lowercase    (   self)	-> None:




										'''simple docstring'''




										lowercase__:    Union[str, Any]        =      self._get_binary_search_tree()

										t.remove(13)
										assert t.root is not None
										assert t.root.right is not None
										assert t.root.right.right is not None
										assert t.root.right.right.right is None
										assert t.root.right.right.left is None

										t.remove(7)
										assert t.root.left is not None
										assert t.root.left.right is not None
										assert t.root.left.right.left is not None
										assert t.root.left.right.right is None
										assert t.root.left.right.left.label == 4

										t.remove(6)
										assert t.root.left.left is not None
										assert t.root.left.right.right is not None
										assert t.root.left.left.label == 1
										assert t.root.left.right.label == 4
										assert t.root.left.right.right.label == 5
										assert t.root.left.right.left is None
										assert t.root.left.left.parent == t.root.left
										assert t.root.left.right.parent == t.root.left

										t.remove(3)
										assert t.root is not None
										assert t.root.left.label == 4
										assert t.root.left.right.label == 5
										assert t.root.left.left.label == 1
										assert t.root.left.parent == t.root
										assert t.root.left.left.parent == t.root.left
										assert t.root.left.right.parent == t.root.left

										t.remove(4)
										assert t.root.left is not None
										assert t.root.left.left is not None
										assert t.root.left.label == 5
										assert t.root.left.right is None
										assert t.root.left.left.label == 1
										assert t.root.left.parent == t.root
										assert t.root.left.left.parent == t.root.left





			def __lowercase    (   self)	-> None:




										'''simple docstring'''




										lowercase__:    Dict        =      self._get_binary_search_tree()

										t.remove(3)
										assert t.root is not None
										assert t.root.left is not None
										assert t.root.left.left is not None
										assert t.root.left.right is not None
										assert t.root.left.right.left is not None
										assert t.root.left.right.right is not None
										assert t.root.left.label == 4
										assert t.root.left.right.label == 6
										assert t.root.left.left.label == 1
										assert t.root.left.right.right.label == 7
										assert t.root.left.right.left.label == 5
										assert t.root.left.parent == t.root
										assert t.root.left.right.parent == t.root.left
										assert t.root.left.left.parent == t.root.left
										assert t.root.left.right.left.parent == t.root.left.right





			def __lowercase    (   self)	-> None:




										'''simple docstring'''




										lowercase__:    Union[str, Any]        =      self._get_binary_search_tree()
										t.empty()
										assert t.root is None





			def __lowercase    (   self)	-> None:




										'''simple docstring'''




										lowercase__:    Union[str, Any]        =      self._get_binary_search_tree()
										assert not t.is_empty()

										t.empty()
										assert t.is_empty()





			def __lowercase    (   self)	-> None:




										'''simple docstring'''




										lowercase__:    Optional[int]        =      self._get_binary_search_tree()

										assert t.exists(6)
										assert not t.exists(-1)





			def __lowercase    (   self)	-> None:




										'''simple docstring'''




										lowercase__:    Optional[int]        =      self._get_binary_search_tree()

										assert t.get_max_label() == 14

										t.empty()
										with self.assertRaises(UpperCAmelCase_):  # noqa: B017
																	t.get_max_label()





			def __lowercase    (   self)	-> None:




										'''simple docstring'''




										lowercase__:    List[str]        =      self._get_binary_search_tree()

										assert t.get_min_label() == 1

										t.empty()
										with self.assertRaises(UpperCAmelCase_):  # noqa: B017
																	t.get_min_label()





			def __lowercase    (   self)	-> None:




										'''simple docstring'''




										lowercase__:    List[Any]        =      self._get_binary_search_tree()

										lowercase__:    List[Any]        =      [i.label for i in t.inorder_traversal()]
										assert inorder_traversal_nodes == [1, 3, 4, 5, 6, 7, 8, 10, 13, 14]





			def __lowercase    (   self)	-> None:




										'''simple docstring'''




										lowercase__:    List[Any]        =      self._get_binary_search_tree()

										lowercase__:    Dict        =      [i.label for i in t.preorder_traversal()]
										assert preorder_traversal_nodes == [8, 3, 1, 6, 4, 5, 7, 10, 14, 13]







def     A(  ):
							"""simple docstring"""





							lowercase__:    str        =      BinarySearchTree()
							t.put(8		)
							t.put(3		)
							t.put(6		)
							t.put(1		)
							t.put(10		)
							t.put(14		)
							t.put(13		)
							t.put(4		)
							t.put(7		)
							t.put(5		)

							print(
							    "\n            8\n           / \\\n          3   10\n         / \\    \\\n        1   6    14\n           / \\   /\n          4   7 13\n           \\\n            5\n        "		)

							print("Label 6 exists:"						,       t.exists(6		)		)
							print("Label 13 exists:"						,       t.exists(13		)		)
							print("Label -1 exists:"						,       t.exists(-1		)		)
							print("Label 12 exists:"						,       t.exists(12		)		)

							# Prints all the elements of the list in inorder traversal
							lowercase__:    str        =      [i.label for i in t.inorder_traversal()]
							print("Inorder traversal:"						,       snake_case_		)

							# Prints all the elements of the list in preorder traversal
							lowercase__:    List[str]        =      [i.label for i in t.preorder_traversal()]
							print("Preorder traversal:"						,       snake_case_		)

							print("Max. label:"						,       t.get_max_label()		)
							print("Min. label:"						,       t.get_min_label()		)

							# Delete elements
							print("\nDeleting elements 13, 10, 8, 3, 6, 14"		)
							print(
							    "\n          4\n         / \\\n        1   7\n             \\\n              5\n        "		)
							t.remove(13		)
							t.remove(10		)
							t.remove(8		)
							t.remove(3		)
							t.remove(6		)
							t.remove(14		)

							# Prints all the elements of the list in inorder traversal after delete
							lowercase__:    List[str]        =      [i.label for i in t.inorder_traversal()]
							print("Inorder traversal after delete:"						,       snake_case_		)

							# Prints all the elements of the list in preorder traversal after delete
							lowercase__:    Optional[int]        =      [i.label for i in t.preorder_traversal()]
							print("Preorder traversal after delete:"						,       snake_case_		)

							print("Max. label:"						,       t.get_max_label()		)
							print("Min. label:"						,       t.get_min_label()		)


if __name__ == "__main__":
		binary_search_tree_example()














"""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 		_a       :





   '''simple docstring'''






   def __init__(   self			,				UpperCAmelCase_			,				UpperCAmelCase_=13			,				UpperCAmelCase_=7			,				UpperCAmelCase_=True			,				UpperCAmelCase_=True			,				UpperCAmelCase_=True			,				UpperCAmelCase_=True			,				UpperCAmelCase_=99			,				UpperCAmelCase_=32			,				UpperCAmelCase_=5			,				UpperCAmelCase_=4			,				UpperCAmelCase_=37			,				UpperCAmelCase_="gelu"			,				UpperCAmelCase_=0.1			,				UpperCAmelCase_=0.1			,				UpperCAmelCase_=512			,				UpperCAmelCase_=16			,				UpperCAmelCase_=2			,				UpperCAmelCase_=0.02			,				UpperCAmelCase_=3			,				UpperCAmelCase_=4			,				UpperCAmelCase_=None			,				UpperCAmelCase_=1_000			,				)	-> Optional[int]:




          '''simple docstring'''




          lowercase__:    int        =      parent
          lowercase__:    str        =      batch_size
          lowercase__:    Tuple        =      seq_length
          lowercase__:    Any        =      is_training
          lowercase__:    Union[str, Any]        =      use_input_mask
          lowercase__:    str        =      use_token_type_ids
          lowercase__:    Optional[int]        =      use_labels
          lowercase__:    List[str]        =      vocab_size
          lowercase__:    Optional[Any]        =      hidden_size
          lowercase__:    Optional[Any]        =      num_hidden_layers
          lowercase__:    Optional[int]        =      num_attention_heads
          lowercase__:    List[str]        =      intermediate_size
          lowercase__:    Any        =      hidden_act
          lowercase__:    Any        =      hidden_dropout_prob
          lowercase__:    List[str]        =      attention_probs_dropout_prob
          lowercase__:    Tuple        =      max_position_embeddings
          lowercase__:    Any        =      type_vocab_size
          lowercase__:    List[str]        =      type_sequence_label_size
          lowercase__:    Dict        =      initializer_range
          lowercase__:    Dict        =      num_labels
          lowercase__:    List[str]        =      num_choices
          lowercase__:    int        =      scope
          lowercase__:    List[Any]        =      range_bbox





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




          '''simple docstring'''




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

          lowercase__:    Tuple        =      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]:
                               lowercase__:    List[str]        =      bbox[i, j, 3]
                               lowercase__:    List[str]        =      bbox[i, j, 1]
                               lowercase__:    Union[str, Any]        =      t
                        if bbox[i, j, 2] < bbox[i, j, 0]:
                               lowercase__:    Optional[int]        =      bbox[i, j, 2]
                               lowercase__:    Tuple        =      bbox[i, j, 0]
                               lowercase__:    Optional[Any]        =      t

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

          lowercase__:    str        =      None
          if self.use_token_type_ids:
                 lowercase__:    List[Any]        =      ids_tensor([self.batch_size, self.seq_length]			,				self.type_vocab_size)

          lowercase__:    Tuple        =      None
          lowercase__:    Dict        =      None
          lowercase__:    Any        =      None
          if self.use_labels:
                 lowercase__:    List[Any]        =      ids_tensor([self.batch_size]			,				self.type_sequence_label_size)
                 lowercase__:    Any        =      ids_tensor([self.batch_size, self.seq_length]			,				self.num_labels)
                 lowercase__:    List[str]        =      ids_tensor([self.batch_size]			,				self.num_choices)

          lowercase__:    int        =      self.get_config()

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





   def __lowercase    (   self)	-> 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 __lowercase    (   self			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_)	-> Optional[Any]:




          '''simple docstring'''




          lowercase__:    Any        =      LayoutLMModel(config=UpperCAmelCase_)
          model.to(UpperCAmelCase_)
          model.eval()
          lowercase__:    Tuple        =      model(UpperCAmelCase_			,				UpperCAmelCase_			,				attention_mask=UpperCAmelCase_			,				token_type_ids=UpperCAmelCase_)
          lowercase__:    Dict        =      model(UpperCAmelCase_			,				UpperCAmelCase_			,				token_type_ids=UpperCAmelCase_)
          lowercase__:    Any        =      model(UpperCAmelCase_			,				UpperCAmelCase_)
          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 __lowercase    (   self			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_)	-> List[Any]:




          '''simple docstring'''




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





   def __lowercase    (   self			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_)	-> Optional[int]:




          '''simple docstring'''




          lowercase__:    Union[str, Any]        =      self.num_labels
          lowercase__:    Optional[Any]        =      LayoutLMForSequenceClassification(UpperCAmelCase_)
          model.to(UpperCAmelCase_)
          model.eval()
          lowercase__:    Optional[Any]        =      model(
              UpperCAmelCase_			,				UpperCAmelCase_			,				attention_mask=UpperCAmelCase_			,				token_type_ids=UpperCAmelCase_			,				labels=UpperCAmelCase_)
          self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_labels))





   def __lowercase    (   self			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_)	-> List[str]:




          '''simple docstring'''




          lowercase__:    List[str]        =      self.num_labels
          lowercase__:    List[str]        =      LayoutLMForTokenClassification(config=UpperCAmelCase_)
          model.to(UpperCAmelCase_)
          model.eval()
          lowercase__:    List[Any]        =      model(UpperCAmelCase_			,				UpperCAmelCase_			,				attention_mask=UpperCAmelCase_			,				token_type_ids=UpperCAmelCase_			,				labels=UpperCAmelCase_)
          self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.seq_length, self.num_labels))





   def __lowercase    (   self			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_			,				UpperCAmelCase_)	-> str:




          '''simple docstring'''




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




          '''simple docstring'''




          lowercase__:    int        =      self.prepare_config_and_inputs()
          (
              (
              lowercase__
          )  ,     (
              lowercase__
          )  ,     (
              lowercase__
          )  ,     (
              lowercase__
          )  ,     (
              lowercase__
          )  ,     (
              lowercase__
          )  ,     (
              lowercase__
          )  ,     (
              lowercase__
          )  ,     
          ):    int        =      config_and_inputs
          lowercase__:    Optional[int]        =      {
              "input_ids": input_ids,
              "bbox": bbox,
              "token_type_ids": token_type_ids,
              "attention_mask": input_mask,
          }
          return config, inputs_dict







@require_torch
class 		_a       (						lowercase_    ,					lowercase_    ,					unittest.TestCase   ):





   '''simple docstring'''






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




          '''simple docstring'''




          lowercase__:    List[str]        =      LayoutLMModelTester(self)
          lowercase__:    List[str]        =      ConfigTester(self			,				config_class=UpperCAmelCase_			,				hidden_size=37)





   def __lowercase    (   self)	-> Optional[Any]:




          '''simple docstring'''




          self.config_tester.run_common_tests()





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




          '''simple docstring'''




          lowercase__:    int        =      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*UpperCAmelCase_)





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




          '''simple docstring'''




          lowercase__:    List[Any]        =      self.model_tester.prepare_config_and_inputs()
          for type in ["absolute", "relative_key", "relative_key_query"]:
                 lowercase__:    Union[str, Any]        =      type
                 self.model_tester.create_and_check_model(*UpperCAmelCase_)





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




          '''simple docstring'''




          lowercase__:    Any        =      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*UpperCAmelCase_)





   def __lowercase    (   self)	-> Dict:




          '''simple docstring'''




          lowercase__:    List[Any]        =      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase_)





   def __lowercase    (   self)	-> int:




          '''simple docstring'''




          lowercase__:    Dict        =      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase_)





   def __lowercase    (   self)	-> str:




          '''simple docstring'''




          lowercase__:    Optional[Any]        =      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase_)





   @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests.")
   def __lowercase    (   self)	-> List[Any]:




          '''simple docstring'''




          pass







def     A(  ):
       """simple docstring"""





       lowercase__:    Any        =      torch.tensor([[101,1019,1014,1016,1037,12849,4747,1004,14246,2278,5439,4524,5002,2930,2193,2930,4341,3208,1005,1055,2171,2848,11300,3531,102],[101,4070,4034,7020,1024,3058,1015,1013,2861,1013,6070,19274,2772,6205,27814,16147,16147,4343,2047,10283,10969,14389,1012,2338,102]]						,       device=snake_case_		)  # noqa: E231
       lowercase__:    Dict        =      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=snake_case_		)  # noqa: E231
       lowercase__:    Optional[Any]        =      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],[1000,1000,1000,1000]],[[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],[1000,1000,1000,1000]]]						,       device=snake_case_		)  # noqa: E231
       lowercase__:    Dict        =      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=snake_case_		)  # noqa: E231
       # these are sequence labels (i.e. at the token level)
       lowercase__:    int        =      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=snake_case_		)  # noqa: E231
       # fmt: on

       return input_ids, attention_mask, bbox, token_type_ids, labels







@require_torch
class 		_a       (						unittest.TestCase   ):





   '''simple docstring'''






   @slow
   def __lowercase    (   self)	-> Any:




          '''simple docstring'''




          lowercase__:    str        =      LayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased").to(UpperCAmelCase_)

          lowercase__  ,     lowercase__  ,     lowercase__  ,     lowercase__  ,     lowercase__:    Dict        =      prepare_layoutlm_batch_inputs()

          # forward pass
          lowercase__:    str        =      model(input_ids=UpperCAmelCase_			,				bbox=UpperCAmelCase_			,				attention_mask=UpperCAmelCase_			,				token_type_ids=UpperCAmelCase_)

          # test the sequence output on [0, :3, :3]
          lowercase__:    Optional[int]        =      torch.tensor(
              [[0.17_85, -0.19_47, -0.04_25], [-0.32_54, -0.28_07, 0.25_53], [-0.53_91, -0.33_22, 0.33_64]]			,				device=UpperCAmelCase_			,				)

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

          # test the pooled output on [1, :3]
          lowercase__:    List[Any]        =      torch.tensor([-0.65_80, -0.02_14, 0.85_52]			,				device=UpperCAmelCase_)

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





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




          '''simple docstring'''




          lowercase__:    int        =      LayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased"			,				num_labels=2).to(
              UpperCAmelCase_)

          lowercase__  ,     lowercase__  ,     lowercase__  ,     lowercase__  ,     lowercase__:    List[Any]        =      prepare_layoutlm_batch_inputs()

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

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

          # test the shape of the logits
          lowercase__:    str        =      outputs.logits
          lowercase__:    Any        =      torch.Size((2, 2))
          self.assertEqual(logits.shape			,				UpperCAmelCase_)





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




          '''simple docstring'''




          lowercase__:    Tuple        =      LayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased"			,				num_labels=13).to(
              UpperCAmelCase_)

          lowercase__  ,     lowercase__  ,     lowercase__  ,     lowercase__  ,     lowercase__:    List[Any]        =      prepare_layoutlm_batch_inputs()

          # forward pass
          lowercase__:    Any        =      model(
              input_ids=UpperCAmelCase_			,				bbox=UpperCAmelCase_			,				attention_mask=UpperCAmelCase_			,				token_type_ids=UpperCAmelCase_			,				labels=UpperCAmelCase_)

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





   @slow
   def __lowercase    (   self)	-> Tuple:




          '''simple docstring'''




          lowercase__:    Tuple        =      LayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased").to(UpperCAmelCase_)

          lowercase__  ,     lowercase__  ,     lowercase__  ,     lowercase__  ,     lowercase__:    Tuple        =      prepare_layoutlm_batch_inputs()

          # forward pass
          lowercase__:    str        =      model(input_ids=UpperCAmelCase_			,				bbox=UpperCAmelCase_			,				attention_mask=UpperCAmelCase_			,				token_type_ids=UpperCAmelCase_)

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






