





'''simple docstring'''






import unittest

import numpy as np

from transformers.testing_utils import require_pytesseract, require_torch
from transformers.utils import is_pytesseract_available, is_torch_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
      import torch

if is_pytesseract_available():
      from PIL import Image

      from transformers import LayoutLMvaImageProcessor




class 			UpperCAmelCase					(      unittest.TestCase       ):




      def __init__(      self      :			Optional[Any]      ,      __snake_case      :			List[str]      ,      __snake_case      :			int=7      ,      __snake_case      :			Optional[Any]=3      ,      __snake_case      :			Optional[int]=18      ,      __snake_case      :			Optional[int]=30      ,      __snake_case      :			Tuple=4_00      ,      __snake_case      :			Optional[int]=True      ,      __snake_case      :			Any=None      ,      __snake_case      :			str=True      ,      )    ->				List[Any]:
            _lowerCAmelCase												=							size if size is not None else {"""height""": 18, """width""": 18}
            _lowerCAmelCase												=							parent
            _lowerCAmelCase												=							batch_size
            _lowerCAmelCase												=							num_channels
            _lowerCAmelCase												=							image_size
            _lowerCAmelCase												=							min_resolution
            _lowerCAmelCase												=							max_resolution
            _lowerCAmelCase												=							do_resize
            _lowerCAmelCase												=							size
            _lowerCAmelCase												=							apply_ocr




      def     lowercase__   (      self      :			str  )    ->				Tuple:
            return {"do_resize": self.do_resize, "size": self.size, "apply_ocr": self.apply_ocr}




@require_torch
@require_pytesseract
class 			UpperCAmelCase					(      snake_case_							,		unittest.TestCase       ):
      _lowercase:      Optional[int]											=       LayoutLMvaImageProcessor if is_pytesseract_available() else None




      def     lowercase__   (      self      :			Any  )    ->				Union[str, Any]:
            _lowerCAmelCase												=							LayoutLMvaImageProcessingTester(self  )




      @property
      def     lowercase__   (      self      :			Tuple  )    ->				Optional[int]:
            return self.image_processor_tester.prepare_image_processor_dict()




      def     lowercase__   (      self      :			Optional[int]  )    ->				Optional[int]:
            _lowerCAmelCase												=							self.image_processing_class(**self.image_processor_dict  )
            self.assertTrue(hasattr(__snake_case      ,      """do_resize"""  )  )
            self.assertTrue(hasattr(__snake_case      ,      """size"""  )  )
            self.assertTrue(hasattr(__snake_case      ,      """apply_ocr"""  )  )




      def     lowercase__   (      self      :			Any  )    ->				Optional[int]:
            _lowerCAmelCase												=							self.image_processing_class.from_dict(self.image_processor_dict  )
            self.assertEqual(image_processor.size      ,      {"""height""": 18, """width""": 18}  )

            _lowerCAmelCase												=							self.image_processing_class.from_dict(self.image_processor_dict      ,      size=42  )
            self.assertEqual(image_processor.size      ,      {"""height""": 42, """width""": 42}  )




      def     lowercase__   (      self      :			List[str]  )    ->				Dict:
            pass




      def     lowercase__   (      self      :			List[str]  )    ->				List[Any]:
            # Initialize image_processing
            _lowerCAmelCase												=							self.image_processing_class(**self.image_processor_dict  )
            # create random PIL images
            _lowerCAmelCase												=							prepare_image_inputs(self.image_processor_tester      ,      equal_resolution=__snake_case  )
            for image in image_inputs:
                  self.assertIsInstance(__snake_case      ,      Image.Image  )

            # Test not batched input
            _lowerCAmelCase												=							image_processing(image_inputs[0]      ,      return_tensors="""pt"""  )
            self.assertEqual(
                encoding.pixel_values.shape      ,      (
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size["""height"""],
                    self.image_processor_tester.size["""width"""],
                )      ,      )

            self.assertIsInstance(encoding.words      ,      __snake_case  )
            self.assertIsInstance(encoding.boxes      ,      __snake_case  )

            # Test batched
            _lowerCAmelCase												=							image_processing(__snake_case      ,      return_tensors="""pt"""  ).pixel_values
            self.assertEqual(
                encoded_images.shape      ,      (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size["""height"""],
                    self.image_processor_tester.size["""width"""],
                )      ,      )




      def     lowercase__   (      self      :			Optional[int]  )    ->				int:
            # Initialize image_processing
            _lowerCAmelCase												=							self.image_processing_class(**self.image_processor_dict  )
            # create random numpy tensors
            _lowerCAmelCase												=							prepare_image_inputs(self.image_processor_tester      ,      equal_resolution=__snake_case      ,      numpify=__snake_case  )
            for image in image_inputs:
                  self.assertIsInstance(__snake_case      ,      np.ndarray  )

            # Test not batched input
            _lowerCAmelCase												=							image_processing(image_inputs[0]      ,      return_tensors="""pt"""  ).pixel_values
            self.assertEqual(
                encoded_images.shape      ,      (
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size["""height"""],
                    self.image_processor_tester.size["""width"""],
                )      ,      )

            # Test batched
            _lowerCAmelCase												=							image_processing(__snake_case      ,      return_tensors="""pt"""  ).pixel_values
            self.assertEqual(
                encoded_images.shape      ,      (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size["""height"""],
                    self.image_processor_tester.size["""width"""],
                )      ,      )




      def     lowercase__   (      self      :			Optional[int]  )    ->				List[Any]:
            # Initialize image_processing
            _lowerCAmelCase												=							self.image_processing_class(**self.image_processor_dict  )
            # create random PyTorch tensors
            _lowerCAmelCase												=							prepare_image_inputs(self.image_processor_tester      ,      equal_resolution=__snake_case      ,      torchify=__snake_case  )
            for image in image_inputs:
                  self.assertIsInstance(__snake_case      ,      torch.Tensor  )

            # Test not batched input
            _lowerCAmelCase												=							image_processing(image_inputs[0]      ,      return_tensors="""pt"""  ).pixel_values
            self.assertEqual(
                encoded_images.shape      ,      (
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size["""height"""],
                    self.image_processor_tester.size["""width"""],
                )      ,      )

            # Test batched
            _lowerCAmelCase												=							image_processing(__snake_case      ,      return_tensors="""pt"""  ).pixel_values
            self.assertEqual(
                encoded_images.shape      ,      (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.size["""height"""],
                    self.image_processor_tester.size["""width"""],
                )      ,      )




      def     lowercase__   (      self      :			Tuple  )    ->				Optional[int]:
            # with apply_OCR = True
            _lowerCAmelCase												=							LayoutLMvaImageProcessor()

            from datasets import load_dataset

            _lowerCAmelCase												=							load_dataset("""hf-internal-testing/fixtures_docvqa"""      ,      split="""test"""  )

            _lowerCAmelCase												=							Image.open(ds[0]["""file"""]  ).convert("""RGB"""  )

            _lowerCAmelCase												=							image_processing(__snake_case      ,      return_tensors="""pt"""  )

            self.assertEqual(encoding.pixel_values.shape      ,      (1, 3, 2_24, 2_24)  )
            self.assertEqual(len(encoding.words  )      ,      len(encoding.boxes  )  )

            # fmt: off
            # the words and boxes were obtained with Tesseract 4.1.1
            _lowerCAmelCase												=							[["""11:14""", """to""", """11:39""", """a.m""", """11:39""", """to""", """11:44""", """a.m.""", """11:44""", """a.m.""", """to""", """12:25""", """p.m.""", """12:25""", """to""", """12:58""", """p.m.""", """12:58""", """to""", """4:00""", """p.m.""", """2:00""", """to""", """5:00""", """p.m.""", """Coffee""", """Break""", """Coffee""", """will""", """be""", """served""", """for""", """men""", """and""", """women""", """in""", """the""", """lobby""", """adjacent""", """to""", """exhibit""", """area.""", """Please""", """move""", """into""", """exhibit""", """area.""", """(Exhibits""", """Open)""", """TRRF""", """GENERAL""", """SESSION""", """(PART""", """|)""", """Presiding:""", """Lee""", """A.""", """Waller""", """TRRF""", """Vice""", """President""", """“Introductory""", """Remarks”""", """Lee""", """A.""", """Waller,""", """TRRF""", """Vice""", """Presi-""", """dent""", """Individual""", """Interviews""", """with""", """TRRF""", """Public""", """Board""", """Members""", """and""", """Sci-""", """entific""", """Advisory""", """Council""", """Mem-""", """bers""", """Conducted""", """by""", """TRRF""", """Treasurer""", """Philip""", """G.""", """Kuehn""", """to""", """get""", """answers""", """which""", """the""", """public""", """refrigerated""", """warehousing""", """industry""", """is""", """looking""", """for.""", """Plus""", """questions""", """from""", """the""", """floor.""", """Dr.""", """Emil""", """M.""", """Mrak,""", """University""", """of""", """Cal-""", """ifornia,""", """Chairman,""", """TRRF""", """Board;""", """Sam""", """R.""", """Cecil,""", """University""", """of""", """Georgia""", """College""", """of""", """Agriculture;""", """Dr.""", """Stanley""", """Charm,""", """Tufts""", """University""", """School""", """of""", """Medicine;""", """Dr.""", """Robert""", """H.""", """Cotton,""", """ITT""", """Continental""", """Baking""", """Company;""", """Dr.""", """Owen""", """Fennema,""", """University""", """of""", """Wis-""", """consin;""", """Dr.""", """Robert""", """E.""", """Hardenburg,""", """USDA.""", """Questions""", """and""", """Answers""", """Exhibits""", """Open""", """Capt.""", """Jack""", """Stoney""", """Room""", """TRRF""", """Scientific""", """Advisory""", """Council""", """Meeting""", """Ballroom""", """Foyer"""]]  # noqa: E231
            _lowerCAmelCase												=							[[[1_41, 57, 2_14, 69], [2_28, 58, 2_52, 69], [1_41, 75, 2_16, 88], [2_30, 79, 2_80, 88], [1_42, 2_60, 2_18, 2_73], [2_30, 2_61, 2_55, 2_73], [1_43, 2_79, 2_18, 2_90], [2_31, 2_82, 2_90, 2_91], [1_43, 3_42, 2_18, 3_54], [2_31, 3_45, 2_89, 3_55], [2_02, 3_62, 2_27, 3_73], [1_43, 3_79, 2_20, 3_92], [2_31, 3_82, 2_91, 3_94], [1_44, 7_14, 2_20, 7_26], [2_31, 7_15, 2_56, 7_26], [1_44, 7_32, 2_20, 7_45], [2_32, 7_36, 2_91, 7_47], [1_44, 7_69, 2_18, 7_82], [2_31, 7_70, 2_56, 7_82], [1_41, 7_88, 2_02, 8_01], [2_15, 7_91, 2_74, 8_04], [1_43, 8_26, 2_04, 8_38], [2_15, 8_26, 2_40, 8_38], [1_42, 8_44, 2_02, 8_57], [2_15, 8_47, 2_74, 8_59], [3_34, 57, 4_27, 69], [4_40, 57, 5_22, 69], [3_69, 75, 4_61, 88], [4_69, 75, 5_16, 88], [5_28, 76, 5_62, 88], [5_70, 76, 6_67, 88], [6_75, 75, 7_11, 87], [7_21, 79, 7_78, 88], [7_89, 75, 8_40, 88], [3_69, 97, 4_70, 1_07], [4_84, 94, 5_07, 1_06], [5_18, 94, 5_62, 1_07], [5_76, 94, 6_55, 1_10], [6_68, 94, 7_92, 1_09], [8_04, 95, 8_29, 1_07], [3_69, 1_13, 4_65, 1_25], [4_77, 1_16, 5_47, 1_25], [5_62, 1_13, 6_58, 1_25], [6_71, 1_16, 7_48, 1_25], [7_61, 1_13, 8_11, 1_25], [3_69, 1_31, 4_65, 1_43], [4_77, 1_33, 5_48, 1_43], [5_63, 1_30, 6_98, 1_45], [7_10, 1_30, 8_02, 1_46], [3_36, 1_71, 4_12, 1_83], [4_23, 1_71, 5_72, 1_83], [5_82, 1_70, 7_16, 1_84], [7_28, 1_71, 8_17, 1_87], [8_29, 1_71, 8_44, 1_86], [3_38, 1_97, 4_82, 2_12], [5_07, 1_96, 5_57, 2_09], [5_69, 1_96, 5_95, 2_08], [6_10, 1_96, 7_02, 2_09], [5_05, 2_14, 5_83, 2_26], [5_95, 2_14, 6_56, 2_27], [6_70, 2_15, 8_07, 2_27], [3_35, 2_59, 5_43, 2_74], [5_56, 2_59, 7_08, 2_72], [3_72, 2_79, 4_22, 2_91], [4_35, 2_79, 4_60, 2_91], [4_74, 2_79, 5_74, 2_92], [5_87, 2_78, 6_64, 2_91], [6_76, 2_78, 7_38, 2_91], [7_51, 2_79, 8_34, 2_91], [3_72, 2_98, 4_34, 3_10], [3_35, 3_41, 4_83, 3_54], [4_97, 3_41, 6_55, 3_54], [6_67, 3_41, 7_28, 3_54], [7_40, 3_41, 8_25, 3_54], [3_35, 3_60, 4_30, 3_72], [4_42, 3_60, 5_34, 3_72], [5_45, 3_59, 6_87, 3_72], [6_97, 3_60, 7_54, 3_72], [7_65, 3_60, 8_23, 3_73], [3_34, 3_78, 4_28, 3_91], [4_40, 3_78, 5_77, 3_94], [5_90, 3_78, 7_05, 3_91], [7_20, 3_78, 8_01, 3_91], [3_34, 3_97, 4_00, 4_09], [3_70, 4_16, 5_29, 4_29], [5_44, 4_16, 5_76, 4_32], [5_87, 4_16, 6_65, 4_28], [6_77, 4_16, 8_14, 4_29], [3_72, 4_35, 4_52, 4_50], [4_65, 4_34, 4_95, 4_47], [5_11, 4_34, 6_00, 4_47], [6_11, 4_36, 6_37, 4_47], [6_49, 4_36, 6_94, 4_51], [7_05, 4_38, 8_24, 4_47], [3_69, 4_53, 4_52, 4_66], [4_64, 4_54, 5_09, 4_66], [5_22, 4_53, 6_11, 4_69], [6_25, 4_53, 7_92, 4_69], [3_70, 4_72, 5_56, 4_88], [5_70, 4_72, 6_84, 4_87], [6_97, 4_72, 7_18, 4_85], [7_32, 4_72, 8_35, 4_88], [3_69, 4_90, 4_11, 5_03], [4_25, 4_90, 4_84, 5_03], [4_96, 4_90, 6_35, 5_06], [6_45, 4_90, 7_07, 5_03], [7_18, 4_91, 7_61, 5_03], [7_71, 4_90, 8_40, 5_03], [3_36, 5_10, 3_74, 5_21], [3_88, 5_10, 4_47, 5_22], [4_60, 5_10, 4_89, 5_21], [5_03, 5_10, 5_80, 5_22], [5_92, 5_09, 7_36, 5_25], [7_45, 5_09, 7_70, 5_22], [7_81, 5_09, 8_40, 5_22], [3_38, 5_28, 4_34, 5_41], [4_48, 5_28, 5_96, 5_41], [6_09, 5_27, 6_87, 5_40], [7_00, 5_28, 7_92, 5_41], [3_36, 5_46, 3_97, 5_59], [4_07, 5_46, 4_31, 5_59], [4_43, 5_46, 5_25, 5_60], [5_37, 5_46, 6_80, 5_62], [6_88, 5_46, 7_14, 5_59], [7_22, 5_46, 8_37, 5_62], [3_36, 5_65, 4_49, 5_81], [4_61, 5_65, 4_85, 5_77], [4_97, 5_65, 6_65, 5_81], [6_81, 5_65, 7_18, 5_77], [7_32, 5_65, 8_37, 5_80], [3_37, 5_84, 4_38, 5_97], [4_52, 5_83, 5_21, 5_96], [5_35, 5_84, 6_77, 5_99], [6_90, 5_83, 7_87, 5_96], [8_01, 5_83, 8_25, 5_96], [3_38, 6_02, 4_78, 6_15], [4_92, 6_02, 5_30, 6_14], [5_43, 6_02, 6_38, 6_15], [6_50, 6_02, 6_76, 6_14], [6_88, 6_02, 7_88, 6_15], [8_02, 6_02, 8_43, 6_14], [3_37, 6_21, 5_02, 6_33], [5_16, 6_21, 6_15, 6_37], [6_29, 6_21, 7_74, 6_36], [7_89, 6_21, 8_27, 6_33], [3_37, 6_39, 4_18, 6_52], [4_32, 6_40, 5_71, 6_53], [5_87, 6_39, 7_31, 6_55], [7_43, 6_39, 7_69, 6_52], [7_80, 6_39, 8_41, 6_52], [3_38, 6_58, 4_40, 6_73], [4_55, 6_58, 4_91, 6_70], [5_08, 6_58, 6_02, 6_71], [6_16, 6_58, 6_38, 6_70], [6_54, 6_58, 8_35, 6_74], [3_37, 6_77, 4_29, 6_89], [3_37, 7_14, 4_82, 7_26], [4_95, 7_14, 5_48, 7_26], [5_61, 7_14, 6_83, 7_26], [3_38, 7_70, 4_61, 7_82], [4_74, 7_69, 5_54, 7_85], [4_89, 7_88, 5_62, 8_03], [5_76, 7_88, 6_43, 8_01], [6_56, 7_87, 7_51, 8_04], [7_64, 7_88, 8_44, 8_01], [3_34, 8_25, 4_21, 8_38], [4_30, 8_24, 5_74, 8_38], [5_84, 8_24, 7_23, 8_41], [3_35, 8_44, 4_50, 8_57], [4_64, 8_43, 5_83, 8_60], [6_28, 8_62, 7_55, 8_75], [7_69, 8_61, 8_48, 8_78]]]  # noqa: E231
            # fmt: on

            self.assertListEqual(encoding.words      ,      __snake_case  )
            self.assertListEqual(encoding.boxes      ,      __snake_case  )

            # with apply_OCR = False
            _lowerCAmelCase												=							LayoutLMvaImageProcessor(apply_ocr=__snake_case  )

            _lowerCAmelCase												=							image_processing(__snake_case      ,      return_tensors="""pt"""  )

            self.assertEqual(encoding.pixel_values.shape      ,      (1, 3, 2_24, 2_24)  )













'''simple docstring'''






import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch
      from torch import nn

      from transformers import MaskFormerSwinBackbone
      from transformers.models.maskformer import MaskFormerSwinModel




class 			UpperCAmelCase					:




      def __init__(      self      :			str      ,      __snake_case      :			Optional[int]      ,      __snake_case      :			Dict=13      ,      __snake_case      :			Dict=32      ,      __snake_case      :			List[str]=2      ,      __snake_case      :			str=3      ,      __snake_case      :			str=16      ,      __snake_case      :			int=[1, 2, 1]      ,      __snake_case      :			Dict=[2, 2, 4]      ,      __snake_case      :			int=2      ,      __snake_case      :			str=2.0      ,      __snake_case      :			List[str]=True      ,      __snake_case      :			Optional[Any]=0.0      ,      __snake_case      :			Optional[Any]=0.0      ,      __snake_case      :			Dict=0.1      ,      __snake_case      :			Tuple="gelu"      ,      __snake_case      :			str=False      ,      __snake_case      :			Any=True      ,      __snake_case      :			Union[str, Any]=0.02      ,      __snake_case      :			Union[str, Any]=1E-5      ,      __snake_case      :			Optional[Any]=True      ,      __snake_case      :			Union[str, Any]=None      ,      __snake_case      :			Any=True      ,      __snake_case      :			Optional[Any]=10      ,      __snake_case      :			Tuple=8      ,      __snake_case      :			List[Any]=["stage1", "stage2", "stage3"]      ,      __snake_case      :			Dict=[1, 2, 3]      ,      )    ->				List[str]:
            _lowerCAmelCase												=							parent
            _lowerCAmelCase												=							batch_size
            _lowerCAmelCase												=							image_size
            _lowerCAmelCase												=							patch_size
            _lowerCAmelCase												=							num_channels
            _lowerCAmelCase												=							embed_dim
            _lowerCAmelCase												=							depths
            _lowerCAmelCase												=							num_heads
            _lowerCAmelCase												=							window_size
            _lowerCAmelCase												=							mlp_ratio
            _lowerCAmelCase												=							qkv_bias
            _lowerCAmelCase												=							hidden_dropout_prob
            _lowerCAmelCase												=							attention_probs_dropout_prob
            _lowerCAmelCase												=							drop_path_rate
            _lowerCAmelCase												=							hidden_act
            _lowerCAmelCase												=							use_absolute_embeddings
            _lowerCAmelCase												=							patch_norm
            _lowerCAmelCase												=							layer_norm_eps
            _lowerCAmelCase												=							initializer_range
            _lowerCAmelCase												=							is_training
            _lowerCAmelCase												=							scope
            _lowerCAmelCase												=							use_labels
            _lowerCAmelCase												=							type_sequence_label_size
            _lowerCAmelCase												=							encoder_stride
            _lowerCAmelCase												=							out_features
            _lowerCAmelCase												=							out_indices




      def     lowercase__   (      self      :			Union[str, Any]  )    ->				List[str]:
            _lowerCAmelCase												=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

            _lowerCAmelCase												=							None
            if self.use_labels:
                  _lowerCAmelCase												=							ids_tensor([self.batch_size]      ,      self.type_sequence_label_size  )

            _lowerCAmelCase												=							self.get_config()

            return config, pixel_values, labels




      def     lowercase__   (      self      :			int  )    ->				Any:
            return MaskFormerSwinConfig(
                image_size=self.image_size      ,      patch_size=self.patch_size      ,      num_channels=self.num_channels      ,      embed_dim=self.embed_dim      ,      depths=self.depths      ,      num_heads=self.num_heads      ,      window_size=self.window_size      ,      mlp_ratio=self.mlp_ratio      ,      qkv_bias=self.qkv_bias      ,      hidden_dropout_prob=self.hidden_dropout_prob      ,      attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,      drop_path_rate=self.drop_path_rate      ,      hidden_act=self.hidden_act      ,      use_absolute_embeddings=self.use_absolute_embeddings      ,      path_norm=self.patch_norm      ,      layer_norm_eps=self.layer_norm_eps      ,      initializer_range=self.initializer_range      ,      encoder_stride=self.encoder_stride      ,      out_features=self.out_features      ,      out_indices=self.out_indices      ,      )




      def     lowercase__   (      self      :			List[str]      ,      __snake_case      :			Tuple      ,      __snake_case      :			Optional[Any]      ,      __snake_case      :			Optional[Any]  )    ->				Dict:
            _lowerCAmelCase												=							MaskFormerSwinModel(config=__snake_case  )
            model.to(__snake_case  )
            model.eval()
            _lowerCAmelCase												=							model(__snake_case  )

            _lowerCAmelCase												=							((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths  ) - 1))
            _lowerCAmelCase												=							int(config.embed_dim * 2 ** (len(config.depths  ) - 1)  )

            self.parent.assertEqual(result.last_hidden_state.shape      ,      (self.batch_size, expected_seq_len, expected_dim)  )




      def     lowercase__   (      self      :			Optional[Any]      ,      __snake_case      :			Any      ,      __snake_case      :			List[Any]      ,      __snake_case      :			Optional[int]  )    ->				Union[str, Any]:
            _lowerCAmelCase												=							MaskFormerSwinBackbone(config=__snake_case  )
            model.to(__snake_case  )
            model.eval()
            _lowerCAmelCase												=							model(__snake_case  )

            # verify feature maps
            self.parent.assertEqual(len(result.feature_maps  )      ,      len(config.out_features  )  )
            self.parent.assertListEqual(list(result.feature_maps[0].shape  )      ,      [13, 16, 16, 16]  )

            # verify channels
            self.parent.assertEqual(len(model.channels  )      ,      len(config.out_features  )  )
            self.parent.assertListEqual(model.channels      ,      [16, 32, 64]  )

            # verify ValueError
            with self.parent.assertRaises(__snake_case  ):
                  _lowerCAmelCase												=							["""stem"""]
                  _lowerCAmelCase												=							MaskFormerSwinBackbone(config=__snake_case  )




      def     lowercase__   (      self      :			Union[str, Any]  )    ->				int:
            _lowerCAmelCase												=							self.prepare_config_and_inputs()
            _lowerCAmelCase					,							_lowerCAmelCase					,							_lowerCAmelCase												=							config_and_inputs
            _lowerCAmelCase												=							{"""pixel_values""": pixel_values}
            return config, inputs_dict




@require_torch
class 			UpperCAmelCase					(      snake_case_							,		snake_case_							,		unittest.TestCase       ):
      _lowercase:      str											=       (
          (
              MaskFormerSwinModel,
              MaskFormerSwinBackbone,
          )
          if is_torch_available()
          else ()
      )
      _lowercase:      List[Any]											=       {'''feature-extraction''': MaskFormerSwinModel} if is_torch_available() else {}
      _lowercase:      Optional[Any]											=       False
      _lowercase:      List[str]											=       False
      _lowercase:      Optional[Any]											=       False
      _lowercase:      str											=       False
      _lowercase:      Union[str, Any]											=       False




      def     lowercase__   (      self      :			Optional[Any]  )    ->				str:
            _lowerCAmelCase												=							MaskFormerSwinModelTester(self  )
            _lowerCAmelCase												=							ConfigTester(self      ,      config_class=__snake_case      ,      embed_dim=37  )




      @require_torch_multi_gpu
      @unittest.skip(
          reason=(
              """`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn't work well with"""
              """ `nn.DataParallel`"""
          )  )
      def     lowercase__   (      self      :			Tuple  )    ->				str:
            pass




      def     lowercase__   (      self      :			str  )    ->				str:
            self.create_and_test_config_common_properties()
            self.config_tester.create_and_test_config_to_json_string()
            self.config_tester.create_and_test_config_to_json_file()
            self.config_tester.create_and_test_config_from_and_save_pretrained()
            self.config_tester.create_and_test_config_with_num_labels()
            self.config_tester.check_config_can_be_init_without_params()
            self.config_tester.check_config_arguments_init()




      def     lowercase__   (      self      :			str  )    ->				Any:
            return




      def     lowercase__   (      self      :			Tuple  )    ->				Tuple:
            _lowerCAmelCase												=							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__snake_case  )




      def     lowercase__   (      self      :			Optional[int]  )    ->				str:
            _lowerCAmelCase												=							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_backbone(*__snake_case  )




      @unittest.skip("""Swin does not use inputs_embeds"""  )
      def     lowercase__   (      self      :			str  )    ->				List[str]:
            pass




      @unittest.skip("""Swin does not support feedforward chunking"""  )
      def     lowercase__   (      self      :			Any  )    ->				Union[str, Any]:
            pass




      def     lowercase__   (      self      :			Optional[Any]  )    ->				List[str]:
            _lowerCAmelCase					,							_lowerCAmelCase												=							self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                  _lowerCAmelCase												=							model_class(__snake_case  )
                  self.assertIsInstance(model.get_input_embeddings()      ,      (nn.Module)  )
                  _lowerCAmelCase												=							model.get_output_embeddings()
                  self.assertTrue(x is None or isinstance(__snake_case      ,      nn.Linear  )  )




      def     lowercase__   (      self      :			str  )    ->				Any:
            _lowerCAmelCase					,							_lowerCAmelCase												=							self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                  _lowerCAmelCase												=							model_class(__snake_case  )
                  _lowerCAmelCase												=							inspect.signature(model.forward  )
                  # signature.parameters is an OrderedDict => so arg_names order is deterministic
                  _lowerCAmelCase												=							[*signature.parameters.keys()]

                  _lowerCAmelCase												=							["""pixel_values"""]
                  self.assertListEqual(arg_names[:1]      ,      __snake_case  )




      @unittest.skip(reason="""MaskFormerSwin is only used as backbone and doesn't support output_attentions"""  )
      def     lowercase__   (      self      :			Union[str, Any]  )    ->				Any:
            pass




      @unittest.skip(reason="""MaskFormerSwin is only used as an internal backbone"""  )
      def     lowercase__   (      self      :			List[str]  )    ->				Any:
            pass




      def     lowercase__   (      self      :			Tuple      ,      __snake_case      :			Optional[int]      ,      __snake_case      :			str      ,      __snake_case      :			str      ,      __snake_case      :			Optional[int]  )    ->				Optional[int]:
            _lowerCAmelCase												=							model_class(__snake_case  )
            model.to(__snake_case  )
            model.eval()

            with torch.no_grad():
                  _lowerCAmelCase												=							model(**self._prepare_for_class(__snake_case      ,      __snake_case  )  )

            _lowerCAmelCase												=							outputs.hidden_states

            _lowerCAmelCase												=							getattr(
                self.model_tester      ,      """expected_num_hidden_layers"""      ,      len(self.model_tester.depths  ) + 1  )
            self.assertEqual(len(__snake_case  )      ,      __snake_case  )

            # Swin has a different seq_length
            _lowerCAmelCase												=							(
                config.patch_size
                if isinstance(config.patch_size      ,      collections.abc.Iterable  )
                else (config.patch_size, config.patch_size)
            )

            _lowerCAmelCase												=							(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

            self.assertListEqual(
                list(hidden_states[0].shape[-2:]  )      ,      [num_patches, self.model_tester.embed_dim]      ,      )




      def     lowercase__   (      self      :			List[str]  )    ->				Any:
            _lowerCAmelCase					,							_lowerCAmelCase												=							self.model_tester.prepare_config_and_inputs_for_common()

            _lowerCAmelCase												=							(
                self.model_tester.image_size
                if isinstance(self.model_tester.image_size      ,      collections.abc.Iterable  )
                else (self.model_tester.image_size, self.model_tester.image_size)
            )

            for model_class in self.all_model_classes:
                  _lowerCAmelCase												=							True
                  self.check_hidden_states_output(__snake_case      ,      __snake_case      ,      __snake_case      ,      __snake_case  )

                  # check that output_hidden_states also work using config
                  del inputs_dict["output_hidden_states"]
                  _lowerCAmelCase												=							True

                  self.check_hidden_states_output(__snake_case      ,      __snake_case      ,      __snake_case      ,      __snake_case  )




      def     lowercase__   (      self      :			Any  )    ->				Any:
            _lowerCAmelCase					,							_lowerCAmelCase												=							self.model_tester.prepare_config_and_inputs_for_common()
            _lowerCAmelCase												=							3

            _lowerCAmelCase												=							(
                self.model_tester.image_size
                if isinstance(self.model_tester.image_size      ,      collections.abc.Iterable  )
                else (self.model_tester.image_size, self.model_tester.image_size)
            )
            _lowerCAmelCase												=							(
                config.patch_size
                if isinstance(config.patch_size      ,      collections.abc.Iterable  )
                else (config.patch_size, config.patch_size)
            )

            _lowerCAmelCase												=							image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
            _lowerCAmelCase												=							image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

            for model_class in self.all_model_classes:
                  _lowerCAmelCase												=							True
                  self.check_hidden_states_output(__snake_case      ,      __snake_case      ,      __snake_case      ,      (padded_height, padded_width)  )

                  # check that output_hidden_states also work using config
                  del inputs_dict["output_hidden_states"]
                  _lowerCAmelCase												=							True
                  self.check_hidden_states_output(__snake_case      ,      __snake_case      ,      __snake_case      ,      (padded_height, padded_width)  )




      @unittest.skip(reason="""MaskFormerSwin doesn't have pretrained checkpoints"""  )
      def     lowercase__   (      self      :			List[Any]  )    ->				Any:
            pass




      @unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""  )
      def     lowercase__   (      self      :			Any  )    ->				str:
            pass




      @unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""  )
      def     lowercase__   (      self      :			Dict  )    ->				Optional[int]:
            pass




      def     lowercase__   (      self      :			List[str]  )    ->				Tuple:
            _lowerCAmelCase					,							_lowerCAmelCase												=							self.model_tester.prepare_config_and_inputs_for_common()

            def set_nan_tensor_to_zero(__snake_case      :			List[str]  ):
                  _lowerCAmelCase												=							0
                  return t

            def check_equivalence(__snake_case      :			Any      ,      __snake_case      :			Optional[Any]      ,      __snake_case      :			Tuple      ,      __snake_case      :			Dict={}  ):
                  with torch.no_grad():
                        _lowerCAmelCase												=							model(**__snake_case      ,      return_dict=__snake_case      ,      **__snake_case  )
                        _lowerCAmelCase												=							model(**__snake_case      ,      return_dict=__snake_case      ,      **__snake_case  ).to_tuple()

                        def recursive_check(__snake_case      :			int      ,      __snake_case      :			Any  ):
                              if isinstance(__snake_case      ,      (List, Tuple)  ):
                                    for tuple_iterable_value, dict_iterable_value in zip(__snake_case      ,      __snake_case  ):
                                          recursive_check(__snake_case      ,      __snake_case  )
                              elif isinstance(__snake_case      ,      __snake_case  ):
                                    for tuple_iterable_value, dict_iterable_value in zip(
                                        tuple_object.values()      ,      dict_object.values()  ):
                                          recursive_check(__snake_case      ,      __snake_case  )
                              elif tuple_object is None:
                                    return
                              else:
                                    self.assertTrue(
                                        torch.allclose(
                                            set_nan_tensor_to_zero(__snake_case  )      ,      set_nan_tensor_to_zero(__snake_case  )      ,      atol=1E-5  )      ,      msg=(
                                            """Tuple and dict output are not equal. Difference:"""
                                            f" {torch.max(torch.abs(tuple_object - dict_object  )  )}. Tuple has `nan`:"
                                            f" {torch.isnan(__snake_case  ).any()} and `inf`: {torch.isinf(__snake_case  )}. Dict has"
                                            f" `nan`: {torch.isnan(__snake_case  ).any()} and `inf`: {torch.isinf(__snake_case  )}."
                                        )      ,      )

                        recursive_check(__snake_case      ,      __snake_case  )

            for model_class in self.all_model_classes:
                  _lowerCAmelCase												=							model_class(__snake_case  )
                  model.to(__snake_case  )
                  model.eval()

                  _lowerCAmelCase												=							self._prepare_for_class(__snake_case      ,      __snake_case  )
                  _lowerCAmelCase												=							self._prepare_for_class(__snake_case      ,      __snake_case  )
                  check_equivalence(__snake_case      ,      __snake_case      ,      __snake_case  )

                  _lowerCAmelCase												=							self._prepare_for_class(__snake_case      ,      __snake_case      ,      return_labels=__snake_case  )
                  _lowerCAmelCase												=							self._prepare_for_class(__snake_case      ,      __snake_case      ,      return_labels=__snake_case  )
                  check_equivalence(__snake_case      ,      __snake_case      ,      __snake_case  )

                  _lowerCAmelCase												=							self._prepare_for_class(__snake_case      ,      __snake_case  )
                  _lowerCAmelCase												=							self._prepare_for_class(__snake_case      ,      __snake_case  )
                  check_equivalence(__snake_case      ,      __snake_case      ,      __snake_case      ,      {"""output_hidden_states""": True}  )

                  _lowerCAmelCase												=							self._prepare_for_class(__snake_case      ,      __snake_case      ,      return_labels=__snake_case  )
                  _lowerCAmelCase												=							self._prepare_for_class(__snake_case      ,      __snake_case      ,      return_labels=__snake_case  )
                  check_equivalence(__snake_case      ,      __snake_case      ,      __snake_case      ,      {"""output_hidden_states""": True}  )




@require_torch
class 			UpperCAmelCase					(      unittest.TestCase							,		snake_case_       ):
      _lowercase:      int											=       (MaskFormerSwinBackbone,) if is_torch_available() else ()
      _lowercase:      Dict											=       MaskFormerSwinConfig




      def     lowercase__   (      self      :			Union[str, Any]  )    ->				str:
            _lowerCAmelCase												=							MaskFormerSwinModelTester(self  )




      def     lowercase__   (      self      :			str  )    ->				Tuple:
            _lowerCAmelCase					,							_lowerCAmelCase												=							self.model_tester.prepare_config_and_inputs_for_common()
            _lowerCAmelCase												=							inputs_dict["""pixel_values"""].shape[0]

            for backbone_class in self.all_model_classes:
                  _lowerCAmelCase												=							backbone_class(__snake_case  )
                  backbone.to(__snake_case  )
                  backbone.eval()

                  _lowerCAmelCase												=							backbone(**__snake_case  )

                  # Test default outputs and verify feature maps
                  self.assertIsInstance(outputs.feature_maps      ,      __snake_case  )
                  self.assertTrue(len(outputs.feature_maps  ) == len(backbone.channels  )  )
                  for feature_map, n_channels in zip(outputs.feature_maps      ,      backbone.channels  ):
                        self.assertTrue(feature_map.shape[:2]      ,      (batch_size, n_channels)  )
                  self.assertIsNone(outputs.hidden_states  )
                  self.assertIsNone(outputs.attentions  )

                  # Test output_hidden_states=True
                  _lowerCAmelCase												=							backbone(**__snake_case      ,      output_hidden_states=__snake_case  )
                  self.assertIsNotNone(outputs.hidden_states  )
                  self.assertTrue(len(outputs.hidden_states  )      ,      len(backbone.stage_names  )  )
                  # We skip the stem layer
                  for hidden_states, n_channels in zip(outputs.hidden_states[1:]      ,      backbone.channels  ):
                        for hidden_state in hidden_states:
                              # Hidden states are in the format (batch_size, (height * width), n_channels)
                              _lowerCAmelCase					,							_lowerCAmelCase					,							_lowerCAmelCase												=							hidden_state.shape
                              self.assertTrue((h_batch_size, h_n_channels)      ,      (batch_size, n_channels)  )

            # Test output_attentions=True
                  if self.has_attentions:
                        _lowerCAmelCase												=							backbone(**__snake_case      ,      output_attentions=__snake_case  )
                        self.assertIsNotNone(outputs.attentions  )






