




'''simple docstring'''





import argparse
import json
import os
import re
from collections import OrderedDict
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from pprint import pprint
from typing import Dict, List, Tuple

import torch
import torch.nn as nn
from classy_vision.models.regnet import RegNet, RegNetParams
from huggingface_hub import cached_download, hf_hub_url
from torch import Tensor
from vissl.models.model_helpers import get_trunk_forward_outputs

from transformers import AutoImageProcessor, RegNetConfig, RegNetForImageClassification, RegNetModel
from transformers.modeling_utils import PreTrainedModel
from transformers.utils import logging


logging.set_verbosity_info()
a		:	Optional[int]       =      logging.get_logger()




@dataclass
class      UpperCamelCase       :
  a     :nn.Module
  a     :List[nn.Module]          =					field(default_factory=snake_case__       )
  a     :list          =					field(default_factory=snake_case__       )
  a     :Dict[str, nn.Module]          =					field(default_factory=snake_case__       )



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							Optional[Any]							       =      len(list(m.modules() ) ) == 1 or isinstance(__lowerCAmelCase		,     nn.Convad ) or isinstance(__lowerCAmelCase		,     nn.BatchNormad )
      if has_not_submodules:
          self.traced.append(__lowerCAmelCase )
          _a				:							Optional[int]							       =      m



  def __call__(			self		,     __lowerCAmelCase ):







      '''simple docstring'''


      for name, m in self.module.named_modules():
          self.handles.append(m.register_forward_hook(partial(self._forward_hook		,     name=__lowerCAmelCase ) ) )
      self.module(__lowerCAmelCase )
      [x.remove() for x in self.handles]
      return self



  @property
  def     a_							(			self ):







      '''simple docstring'''


      return {k: v for k, v in self.nameamodule.items() if len(list(v.state_dict().keys() ) ) > 0}






class      UpperCamelCase       (	nn.Module       ):



  def __init__(			self		,     __lowerCAmelCase ):







      '''simple docstring'''


      super().__init__()

      _a				:							List[Tuple[str, nn.Module]]							       =      []
      # - get the stem
      feature_blocks.append(("""conv1""", model.stem) )
      # - get all the feature blocks
      for k, v in model.trunk_output.named_children():
          assert k.startswith("""block""" ), f'''Unexpected layer name {k}'''
          _a				:							Tuple							       =      len(__lowerCAmelCase ) + 1
          feature_blocks.append((f'''res{block_index}''', v) )

      _a				:							List[str]							       =      nn.ModuleDict(__lowerCAmelCase )



  def     a_							(			self		,     __lowerCAmelCase ):







      '''simple docstring'''


      return get_trunk_forward_outputs(
          __lowerCAmelCase		,     out_feat_keys=__lowerCAmelCase		,     feature_blocks=self._feature_blocks		,     )






class      UpperCamelCase       (	snake_case__       ):



  def     a_							(			self ):







      '''simple docstring'''


      return [(8, 2, 2, 8, 1.0), (8, 2, 7, 8, 1.0), (8, 2, 17, 8, 1.0), (8, 2, 1, 8, 1.0)]






def UpperCAmelCase    (       UpperCAmelCase_						):
    _a				:							Any							       =      RegNetConfig(depths=[2, 7, 17, 1]   ,	hidden_sizes=[8, 8, 8, 8]   ,	groups_width=8						)
    if "in1k" in model_name:
        _a				:							Dict							       =      RegNetForImageClassification(UpperCAmelCase_						)
    else:
        _a				:							str							       =      RegNetModel(UpperCAmelCase_						)
    # create from model (with small weights)
    _a				:							Union[str, Any]							       =      FakeRegNetVisslWrapper(
        RegNet(FakeRegNetParams(depth=27   ,	group_width=1_010   ,	w_a=1_744   ,	w_a=620.83   ,	w_m=2.52						)						)						)

    with torch.no_grad():
        _a				:							Tuple							       =      from_model.eval()
        _a				:							List[str]							       =      our_model.eval()

        _a				:							int							       =      torch.randn((1, 3, 32, 32)						)
        # trace both
        _a				:							Union[str, Any]							       =      Tracker(UpperCAmelCase_						)
        _a				:							Any							       =      dest_tracker(UpperCAmelCase_						).parametrized

        pprint(dest_tracker.nameamodule						)
        _a				:							List[str]							       =      Tracker(UpperCAmelCase_						)
        _a				:							Dict							       =      src_tracker(UpperCAmelCase_						).parametrized

    # convert the keys -> module dict to keys -> params
    def to_params_dict(UpperCAmelCase_						):
        _a				:							List[Any]							       =      OrderedDict()
        for name, module in dict_with_modules.items():
            for param_name, param in module.state_dict().items():
                _a				:							Any							       =      param
        return params_dict

    _a				:							Optional[int]							       =      {}

    _a				:							Optional[Any]							       =      to_params_dict(UpperCAmelCase_						)
    _a				:							Tuple							       =      to_params_dict(UpperCAmelCase_						)

    for (src_key, src_param), (dest_key, dest_param) in zip(src_state_dict.items()   ,	dst_state_dict.items()						):
        _a				:							Dict							       =      dest_key
        logger.info(F'''{src_key} -> {dest_key}'''						)
    # if "in1k" was in the model_name it means it must have a classification head (was finetuned)
    if "in1k" in model_name:
        _a				:							str							       =      """classifier.1.weight"""
        _a				:							str							       =      """classifier.1.bias"""

    return from_to_ours_keys





def UpperCAmelCase    (       UpperCAmelCase_   ,	UpperCAmelCase_ = None   ,	UpperCAmelCase_ = True						):
    _a				:							Union[str, Any]							       =      """imagenet-1k-id2label.json"""
    _a				:							Optional[Any]							       =      1_000

    _a				:							List[Any]							       =      """huggingface/label-files"""
    _a				:							List[Any]							       =      num_labels
    _a				:							Any							       =      json.load(open(cached_download(hf_hub_url(UpperCAmelCase_   ,	UpperCAmelCase_   ,	repo_type="""dataset"""						)						)   ,	"""r"""						)						)
    _a				:							List[Any]							       =      {int(UpperCAmelCase_						): v for k, v in idalabel.items()}

    _a				:							Optional[int]							       =      idalabel
    _a				:							List[str]							       =      {v: k for k, v in idalabel.items()}

    _a				:							int							       =      partial(UpperCAmelCase_   ,	num_labels=UpperCAmelCase_   ,	idalabel=UpperCAmelCase_   ,	labelaid=UpperCAmelCase_						)

    _a				:							Any							       =      {
        """regnet-y-10b-seer""": ImageNetPreTrainedConfig(
            depths=[2, 7, 17, 1]   ,	hidden_sizes=[2_020, 4_040, 11_110, 28_280]   ,	groups_width=1_010						),
        # finetuned on imagenet
        """regnet-y-10b-seer-in1k""": ImageNetPreTrainedConfig(
            depths=[2, 7, 17, 1]   ,	hidden_sizes=[2_020, 4_040, 11_110, 28_280]   ,	groups_width=1_010						),
    }

    # add seer weights logic
    def load_using_classy_vision(UpperCAmelCase_						) -> Tuple[Dict, Dict]:
        _a				:							Any							       =      torch.hub.load_state_dict_from_url(UpperCAmelCase_   ,	model_dir=str(UpperCAmelCase_						)   ,	map_location="""cpu"""						)
        # check if we have a head, if yes add it
        _a				:							Optional[int]							       =      files["""classy_state_dict"""]["""base_model"""]["""model"""]
        return model_state_dict["trunk"], model_state_dict["heads"]

    _a				:							Tuple							       =      {
        """regnet-y-10b-seer""": partial(
            UpperCAmelCase_   ,	"""https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet10B/model_iteration124500_conso.torch"""   ,	),
        """regnet-y-10b-seer-in1k""": partial(
            UpperCAmelCase_   ,	"""https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_10b_finetuned_in1k_model_phase28_conso.torch"""   ,	),
    }

    _a				:							Optional[Any]							       =      get_from_to_our_keys(UpperCAmelCase_						)

    if not (save_directory / F'''{model_name}.pth''').exists():
        logger.info("""Loading original state_dict."""						)
        _a       , _a				:							Dict							       =      names_to_from_model[model_name]()
        _a				:							Any							       =      from_state_dict_trunk
        if "in1k" in model_name:
            # add the head
            _a				:							str							       =      {**from_state_dict_trunk, **from_state_dict_head}
        logger.info("""Done!"""						)

        _a				:							List[Any]							       =      {}

        _a				:							int							       =      list(from_state_dict.keys()						)
        _a				:							str							       =      r"""\.block.-part."""
        # this is "interesting", so the original checkpoints have `block[0,1]-part` in each key name, we remove it
        for key in from_state_dict.keys():
            # remove the weird "block[0,1]-part" from the key
            _a				:							str							       =      re.sub(UpperCAmelCase_   ,	""""""   ,	UpperCAmelCase_						)
            # now src_key from the model checkpoints is the one we got from the original model after tracing, so use it to get the correct destination key
            _a				:							int							       =      from_to_ours_keys[src_key]
            # store the parameter with our key
            _a				:							Tuple							       =      from_state_dict[key]
            not_used_keys.remove(UpperCAmelCase_						)
        # check that all keys have been updated
        assert len(UpperCAmelCase_						) == 0, F'''Some keys where not used {','.join(UpperCAmelCase_						)}'''

        logger.info(F'''The following keys were not used: {','.join(UpperCAmelCase_						)}'''						)

        # save our state dict to disk
        torch.save(UpperCAmelCase_   ,	save_directory / F'''{model_name}.pth'''						)

        del converted_state_dict
    else:
        logger.info("""The state_dict was already stored on disk."""						)
    if push_to_hub:
        logger.info(F'''Token is {os.environ['HF_TOKEN']}'''						)
        logger.info("""Loading our model."""						)
        # create our model
        _a				:							Tuple							       =      names_to_config[model_name]
        _a				:							Tuple							       =      RegNetModel
        if "in1k" in model_name:
            _a				:							Tuple							       =      RegNetForImageClassification
        _a				:							Optional[Any]							       =      our_model_func(UpperCAmelCase_						)
        # place our model to the meta device (so remove all the weights)
        our_model.to(torch.device("""meta"""						)						)
        logger.info("""Loading state_dict in our model."""						)
        # load state dict
        _a				:							Optional[Any]							       =      our_model.state_dict().keys()
        PreTrainedModel._load_pretrained_model_low_mem(
            UpperCAmelCase_   ,	UpperCAmelCase_   ,	[save_directory / F'''{model_name}.pth''']						)
        logger.info("""Finally, pushing!"""						)
        # push it to hub
        our_model.push_to_hub(
            repo_path_or_name=save_directory / model_name   ,	commit_message="""Add model"""   ,	output_dir=save_directory / model_name   ,	)
        _a				:							int							       =      384
        # we can use the convnext one
        _a				:							List[str]							       =      AutoImageProcessor.from_pretrained("""facebook/convnext-base-224-22k-1k"""   ,	size=UpperCAmelCase_						)
        image_processor.push_to_hub(
            repo_path_or_name=save_directory / model_name   ,	commit_message="""Add image processor"""   ,	output_dir=save_directory / model_name   ,	)


if __name__ == "__main__":
  a		:	Optional[Any]       =      argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '''--model_name''',
      default=None,
      type=str,
      help=(
          '''The name of the model you wish to convert, it must be one of the supported regnet* architecture,'''
          ''' currently: regnetx-*, regnety-*. If `None`, all of them will the converted.'''
      ),
  )
  parser.add_argument(
      '''--pytorch_dump_folder_path''',
      default=None,
      type=Path,
      required=True,
      help='''Path to the output PyTorch model directory.''',
  )
  parser.add_argument(
      '''--push_to_hub''',
      default=True,
      type=bool,
      required=False,
      help='''If True, push model and image processor to the hub.''',
  )

  a		:	Optional[int]       =      parser.parse_args()

  a		:	Path       =      args.pytorch_dump_folder_path
  pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
  convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)





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







 """simple docstring"""







 def __init__(     self				:     Optional[int],   UpperCAmelCase__				:     Any,   UpperCAmelCase__				:     Dict=1_3,   UpperCAmelCase__				:     Tuple=7,   UpperCAmelCase__				:     Union[str, Any]=True,   UpperCAmelCase__				:     Tuple=True,   UpperCAmelCase__				:     Dict=True,   UpperCAmelCase__				:     List[str]=True,   UpperCAmelCase__				:     Optional[int]=9_9,   UpperCAmelCase__				:     Union[str, Any]=3_2,   UpperCAmelCase__				:     str=5,   UpperCAmelCase__				:     int=4,   UpperCAmelCase__				:     Any=3_7,   UpperCAmelCase__				:     Tuple="gelu",   UpperCAmelCase__				:     str=0.1,   UpperCAmelCase__				:     Tuple=0.1,   UpperCAmelCase__				:     Any=5_1_2,   UpperCAmelCase__				:     Optional[Any]=1_6,   UpperCAmelCase__				:     Optional[Any]=2,   UpperCAmelCase__				:     Tuple=0.02,   UpperCAmelCase__				:     List[str]=3,   UpperCAmelCase__				:     Any=4,   UpperCAmelCase__				:     Dict=None,   UpperCAmelCase__				:     Dict=1_0_0_0,   ):
    __lowercase								=		parent
    __lowercase								=		batch_size
    __lowercase								=		seq_length
    __lowercase								=		is_training
    __lowercase								=		use_input_mask
    __lowercase								=		use_token_type_ids
    __lowercase								=		use_labels
    __lowercase								=		vocab_size
    __lowercase								=		hidden_size
    __lowercase								=		num_hidden_layers
    __lowercase								=		num_attention_heads
    __lowercase								=		intermediate_size
    __lowercase								=		hidden_act
    __lowercase								=		hidden_dropout_prob
    __lowercase								=		attention_probs_dropout_prob
    __lowercase								=		max_position_embeddings
    __lowercase								=		type_vocab_size
    __lowercase								=		type_sequence_label_size
    __lowercase								=		initializer_range
    __lowercase								=		num_labels
    __lowercase								=		num_choices
    __lowercase								=		scope
    __lowercase								=		range_bbox


 def    _lowercase					(     self				:     Union[str, Any]      ):
    __lowercase								=		ids_tensor([self.batch_size, self.seq_length],   self.vocab_size      )

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

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

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

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

    __lowercase								=		self.get_config()

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


 def    _lowercase					(     self				:     Tuple      ):
    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				:     Optional[Any],   UpperCAmelCase__				:     Any,   UpperCAmelCase__				:     Union[str, Any],   UpperCAmelCase__				:     str,   UpperCAmelCase__				:     Optional[int],   UpperCAmelCase__				:     List[Any],   UpperCAmelCase__				:     Union[str, Any],   UpperCAmelCase__				:     List[str],   UpperCAmelCase__				:     Any      ):
    __lowercase								=		LayoutLMModel(config=UpperCAmelCase__      )
    model.to(UpperCAmelCase__      )
    model.eval()
    __lowercase								=		model(UpperCAmelCase__,   UpperCAmelCase__,   attention_mask=UpperCAmelCase__,   token_type_ids=UpperCAmelCase__      )
    __lowercase								=		model(UpperCAmelCase__,   UpperCAmelCase__,   token_type_ids=UpperCAmelCase__      )
    __lowercase								=		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				:     Tuple,   UpperCAmelCase__				:     Tuple,   UpperCAmelCase__				:     List[Any],   UpperCAmelCase__				:     Union[str, Any],   UpperCAmelCase__				:     Dict,   UpperCAmelCase__				:     Union[str, Any],   UpperCAmelCase__				:     Any,   UpperCAmelCase__				:     Optional[int],   UpperCAmelCase__				:     Dict      ):
    __lowercase								=		LayoutLMForMaskedLM(config=UpperCAmelCase__      )
    model.to(UpperCAmelCase__      )
    model.eval()
    __lowercase								=		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				:     Tuple,   UpperCAmelCase__				:     int,   UpperCAmelCase__				:     Union[str, Any],   UpperCAmelCase__				:     Optional[int],   UpperCAmelCase__				:     List[Any],   UpperCAmelCase__				:     Union[str, Any],   UpperCAmelCase__				:     List[str],   UpperCAmelCase__				:     Dict,   UpperCAmelCase__				:     Optional[int]      ):
    __lowercase								=		self.num_labels
    __lowercase								=		LayoutLMForSequenceClassification(UpperCAmelCase__      )
    model.to(UpperCAmelCase__      )
    model.eval()
    __lowercase								=		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				:     Any,   UpperCAmelCase__				:     Union[str, Any],   UpperCAmelCase__				:     Any,   UpperCAmelCase__				:     str,   UpperCAmelCase__				:     List[Any],   UpperCAmelCase__				:     Dict,   UpperCAmelCase__				:     str,   UpperCAmelCase__				:     Union[str, Any],   UpperCAmelCase__				:     Any      ):
    __lowercase								=		self.num_labels
    __lowercase								=		LayoutLMForTokenClassification(config=UpperCAmelCase__      )
    model.to(UpperCAmelCase__      )
    model.eval()
    __lowercase								=		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				:     Optional[Any],   UpperCAmelCase__				:     int,   UpperCAmelCase__				:     Dict,   UpperCAmelCase__				:     Optional[int],   UpperCAmelCase__				:     str,   UpperCAmelCase__				:     List[Any],   UpperCAmelCase__				:     List[str],   UpperCAmelCase__				:     int,   UpperCAmelCase__				:     Dict      ):
    __lowercase								=		LayoutLMForQuestionAnswering(config=UpperCAmelCase__      )
    model.to(UpperCAmelCase__      )
    model.eval()
    __lowercase								=		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				:     Optional[int]      ):
    __lowercase								=		self.prepare_config_and_inputs()
    (
        (
        __lowercase
    )						,(
        __lowercase
    )						,(
        __lowercase
    )						,(
        __lowercase
    )						,(
        __lowercase
    )						,(
        __lowercase
    )						,(
        __lowercase
    )						,(
        __lowercase
    )						,
    )								=		config_and_inputs
    __lowercase								=		{
        "input_ids": input_ids,
        "bbox": bbox,
        "token_type_ids": token_type_ids,
        "attention_mask": input_mask,
    }
    return config, inputs_dict







@require_torch
class    _lowerCAmelCase    (      lowercase	,lowercase	,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      :   int  						=      True


 def    _lowercase					(     self				:     str      ):
    __lowercase								=		LayoutLMModelTester(self      )
    __lowercase								=		ConfigTester(self,   config_class=UpperCAmelCase__,   hidden_size=3_7      )


 def    _lowercase					(     self				:     int      ):
    self.config_tester.run_common_tests()


 def    _lowercase					(     self				:     List[str]      ):
    __lowercase								=		self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*UpperCAmelCase__      )


 def    _lowercase					(     self				:     Optional[int]      ):
    __lowercase								=		self.model_tester.prepare_config_and_inputs()
    for type in ["absolute", "relative_key", "relative_key_query"]:
       __lowercase								=		type
       self.model_tester.create_and_check_model(*UpperCAmelCase__      )


 def    _lowercase					(     self				:     List[Any]      ):
    __lowercase								=		self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_masked_lm(*UpperCAmelCase__      )


 def    _lowercase					(     self				:     Optional[Any]      ):
    __lowercase								=		self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase__      )


 def    _lowercase					(     self				:     Union[str, Any]      ):
    __lowercase								=		self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase__      )


 def    _lowercase					(     self				:     Optional[int]      ):
    __lowercase								=		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				:     Tuple      ):
    pass







def     _A    (    )      ->		Optional[int]:
   '''simple docstring'''


   __lowercase								=		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=UpperCamelCase_)  # noqa: E231
   __lowercase								=		torch.tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],],     device=UpperCamelCase_)  # noqa: E231
   __lowercase								=		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=UpperCamelCase_)  # noqa: E231
   __lowercase								=		torch.tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]],     device=UpperCamelCase_)  # noqa: E231
   # these are sequence labels (i.e. at the token level)
   __lowercase								=		torch.tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]],     device=UpperCamelCase_)  # noqa: E231
   # fmt: on

   return input_ids, attention_mask, bbox, token_type_ids, labels




@require_torch
class    _lowerCAmelCase    (      unittest.TestCase  ):







 """simple docstring"""







 @slow
 def    _lowercase					(     self				:     Dict      ):
    __lowercase								=		LayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"      ).to(UpperCAmelCase__      )

    __lowercase						,__lowercase						,__lowercase						,__lowercase						,__lowercase								=		prepare_layoutlm_batch_inputs()

    # forward pass
    __lowercase								=		model(input_ids=UpperCAmelCase__,   bbox=UpperCAmelCase__,   attention_mask=UpperCAmelCase__,   token_type_ids=UpperCAmelCase__      )

    # test the sequence output on [0, :3, :3]
    __lowercase								=		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=UpperCAmelCase__,   )

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

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

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


 @slow
 def    _lowercase					(     self				:     str      ):
    # initialize model with randomly initialized sequence classification head
    __lowercase								=		LayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased",   num_labels=2      ).to(
        UpperCAmelCase__      )

    __lowercase						,__lowercase						,__lowercase						,__lowercase						,__lowercase								=		prepare_layoutlm_batch_inputs()

    # forward pass
    __lowercase								=		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								=		outputs.loss
    __lowercase								=		torch.Size([]      )
    self.assertEqual(loss.shape,   UpperCAmelCase__      )

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


 @slow
 def    _lowercase					(     self				:     List[str]      ):
    # initialize model with randomly initialized token classification head
    __lowercase								=		LayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased",   num_labels=1_3      ).to(
        UpperCAmelCase__      )

    __lowercase						,__lowercase						,__lowercase						,__lowercase						,__lowercase								=		prepare_layoutlm_batch_inputs()

    # forward pass
    __lowercase								=		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								=		outputs.logits
    __lowercase								=		torch.Size((2, 2_5, 1_3)      )
    self.assertEqual(logits.shape,   UpperCAmelCase__      )



 @slow
 def    _lowercase					(     self				:     Dict      ):
    # initialize model with randomly initialized token classification head
    __lowercase								=		LayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"      ).to(UpperCAmelCase__      )

    __lowercase						,__lowercase						,__lowercase						,__lowercase						,__lowercase								=		prepare_layoutlm_batch_inputs()

    # forward pass
    __lowercase								=		model(input_ids=UpperCAmelCase__,   bbox=UpperCAmelCase__,   attention_mask=UpperCAmelCase__,   token_type_ids=UpperCAmelCase__      )

    # test the shape of the logits
    __lowercase								=		torch.Size((2, 2_5)      )
    self.assertEqual(outputs.start_logits.shape,   UpperCAmelCase__      )
    self.assertEqual(outputs.end_logits.shape,   UpperCAmelCase__      )




