

import logging
import math
from functools import partial
from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple, Union

import torch

from .tensor_utils import tensor_tree_map, tree_map







def 							_lowerCamelCase   (			SCREAMING_SNAKE_CASE   ):
      '''simple docstring'''







      A_							       =		[]
      if isinstance(_lowerCAmelCase		,				_lowerCAmelCase   ):
            for v in tree.values():
                  shapes.extend(_fetch_dims(_lowerCAmelCase   )   )
      elif isinstance(_lowerCAmelCase		,				(list, tuple)   ):
            for t in tree:
                  shapes.extend(_fetch_dims(_lowerCAmelCase   )   )
      elif isinstance(_lowerCAmelCase		,				torch.Tensor   ):
            shapes.append(tree.shape   )
      else:
            raise ValueError('''Not supported'''   )

      return shapes







@torch.jit.ignore
def 							_lowerCamelCase   (			SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE   ):
      '''simple docstring'''







      A_							       =		[]
      for d in reversed(_lowerCAmelCase   ):
            idx.append(flat_idx % d   )
            A_							       =		flat_idx // d

      return tuple(reversed(_lowerCAmelCase   )   )







@torch.jit.ignore
def 							_lowerCamelCase   (			SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE = None		,				SCREAMING_SNAKE_CASE = None		,				):
      '''simple docstring'''







      def reduce_edge_list(SCREAMING_SNAKE_CASE   ) -> None:
            A_							       =		True
            for i in range(len(_lowerCAmelCase   )   ):
                  A_							       =		-1 * (i + 1)
                  l[reversed_idx] &= tally
                  A_							       =		l[reversed_idx]

      if start_edges is None:
            A_							       =		[s == 0 for s in start]
            reduce_edge_list(_lowerCAmelCase   )
      if end_edges is None:
            A_							       =		[e == (d - 1) for e, d in zip(_lowerCAmelCase		,				_lowerCAmelCase   )]
            reduce_edge_list(_lowerCAmelCase   )

      # Base cases. Either start/end are empty and we're done, or the final,
      # one-dimensional tensor can be simply sliced
      if len(_lowerCAmelCase   ) == 0:
            return [()]
      elif len(_lowerCAmelCase   ) == 1:
            return [(slice(start[0]		,				end[0] + 1   ),)]

      A_							       =		[]
      A_							       =		[]

      # Dimensions common to start and end can be selected directly
      for s, e in zip(_lowerCAmelCase		,				_lowerCAmelCase   ):
            if s == e:
                  path_list.append(slice(_lowerCAmelCase		,				s + 1   )   )
            else:
                  break

      A_							       =		tuple(_lowerCAmelCase   )
      A_							       =		len(_lowerCAmelCase   )

      # start == end, and we're done
      if divergence_idx == len(_lowerCAmelCase   ):
            return [path]

      def upper() -> Tuple[Tuple[slice, ...], ...]:
            assert start_edges is not None
            assert end_edges is not None

            A_							       =		start[divergence_idx]
            return tuple(
                path + (slice(_lowerCAmelCase		,				sdi + 1   ),) + s
                for s in _get_minimal_slice_set(
                    start[divergence_idx + 1 :]		,				[d - 1 for d in dims[divergence_idx + 1 :]]		,				dims[divergence_idx + 1 :]		,				start_edges=start_edges[divergence_idx + 1 :]		,				end_edges=[True for _ in end_edges[divergence_idx + 1 :]]		,				)   )

      def lower() -> Tuple[Tuple[slice, ...], ...]:
            assert start_edges is not None
            assert end_edges is not None

            A_							       =		end[divergence_idx]
            return tuple(
                path + (slice(_lowerCAmelCase		,				edi + 1   ),) + s
                for s in _get_minimal_slice_set(
                    [0 for _ in start[divergence_idx + 1 :]]		,				end[divergence_idx + 1 :]		,				dims[divergence_idx + 1 :]		,				start_edges=[True for _ in start_edges[divergence_idx + 1 :]]		,				end_edges=end_edges[divergence_idx + 1 :]		,				)   )

      # If both start and end are at the edges of the subtree rooted at
      # divergence_idx, we can just select the whole subtree at once
      if start_edges[divergence_idx] and end_edges[divergence_idx]:
            slices.append(path + (slice(start[divergence_idx]		,				end[divergence_idx] + 1   ),)   )
      # If just start is at the edge, we can grab almost all of the subtree,
      # treating only the ragged bottom edge as an edge case
      elif start_edges[divergence_idx]:
            slices.append(path + (slice(start[divergence_idx]		,				end[divergence_idx]   ),)   )
            slices.extend(lower()   )
      # Analogous to the previous case, but the top is ragged this time
      elif end_edges[divergence_idx]:
            slices.extend(upper()   )
            slices.append(path + (slice(start[divergence_idx] + 1		,				end[divergence_idx] + 1   ),)   )
      # If both sides of the range are ragged, we need to handle both sides
      # separately. If there's contiguous meat in between them, we can index it
      # in one big chunk
      else:
            slices.extend(upper()   )
            A_							       =		end[divergence_idx] - start[divergence_idx]
            if middle_ground > 1:
                  slices.append(path + (slice(start[divergence_idx] + 1		,				end[divergence_idx]   ),)   )
            slices.extend(lower()   )

      return slices







@torch.jit.ignore
def 							_lowerCamelCase   (			SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE   ):
      '''simple docstring'''







      A_							       =		t.shape[:no_batch_dims]
      A_							       =		list(_flat_idx_to_idx(_lowerCAmelCase		,				_lowerCAmelCase   )   )
      # _get_minimal_slice_set is inclusive
      A_							       =		list(_flat_idx_to_idx(flat_end - 1		,				_lowerCAmelCase   )   )

      # Get an ordered list of slices to perform
      A_							       =		_get_minimal_slice_set(
          _lowerCAmelCase		,				_lowerCAmelCase		,				_lowerCAmelCase		,				)

      A_							       =		[t[s] for s in slices]

      return torch.cat([s.view((-1,) + t.shape[no_batch_dims:]   ) for s in sliced_tensors]   )







def 							_lowerCamelCase   (			SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE = False		,				SCREAMING_SNAKE_CASE = None		,				SCREAMING_SNAKE_CASE = False		,				):
      '''simple docstring'''







      if not (len(_lowerCAmelCase   ) > 0):
            raise ValueError('''Must provide at least one input'''   )

      A_							       =		[shape[:no_batch_dims] for shape in _fetch_dims(_lowerCAmelCase   )]
      A_							       =		tuple([max(_lowerCAmelCase   ) for s in zip(*_lowerCAmelCase   )]   )

      def _prep_inputs(SCREAMING_SNAKE_CASE   ) -> torch.Tensor:
            if not low_mem:
                  if not sum(t.shape[:no_batch_dims]   ) == no_batch_dims:
                        A_							       =		t.expand(orig_batch_dims + t.shape[no_batch_dims:]   )
                  A_							       =		t.reshape(-1		,				*t.shape[no_batch_dims:]   )
            else:
                  A_							       =		t.expand(orig_batch_dims + t.shape[no_batch_dims:]   )
            return t

      A_							       =		tensor_tree_map(_prep_inputs		,				_lowerCAmelCase   )
      A_							       =		None
      if _out is not None:
            A_							       =		tensor_tree_map(lambda SCREAMING_SNAKE_CASE   : t.view([-1] + list(t.shape[no_batch_dims:]   )   )		,				_out   )

      A_							       =		1
      for d in orig_batch_dims:
            flat_batch_dim *= d

      A_							       =		flat_batch_dim // chunk_size + (flat_batch_dim % chunk_size != 0)

      def _select_chunk(SCREAMING_SNAKE_CASE   ) -> torch.Tensor:
            return t[i : i + chunk_size] if t.shape[0] != 1 else t

      A_							       =		0
      A_							       =		prepped_outputs
      for _ in range(_lowerCAmelCase   ):
            # Chunk the input
            if not low_mem:
                  A_							       =		_select_chunk
            else:
                  A_							       =		partial(
                      _chunk_slice		,				flat_start=_lowerCAmelCase		,				flat_end=min(_lowerCAmelCase		,				i + chunk_size   )		,				no_batch_dims=len(_lowerCAmelCase   )		,				)

            A_							       =		tensor_tree_map(_lowerCAmelCase		,				_lowerCAmelCase   )

            # Run the layer on the chunk
            A_							       =		layer(**_lowerCAmelCase   )

            # Allocate space for the output
            if out is None:
                  A_							       =		tensor_tree_map(lambda SCREAMING_SNAKE_CASE   : t.new_zeros((flat_batch_dim,) + t.shape[1:]   )		,				_lowerCAmelCase   )

            # Put the chunk in its pre-allocated space
            if isinstance(_lowerCAmelCase		,				_lowerCAmelCase   ):

                  def assign(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE   ) -> None:
                        for k, v in da.items():
                              if isinstance(_lowerCAmelCase		,				_lowerCAmelCase   ):
                                    assign(_lowerCAmelCase		,				da[k]   )
                              else:
                                    if _add_into_out:
                                          v[i : i + chunk_size] += da[k]
                                    else:
                                          A_							       =		da[k]

                  assign(_lowerCAmelCase		,				_lowerCAmelCase   )
            elif isinstance(_lowerCAmelCase		,				_lowerCAmelCase   ):
                  for xa, xa in zip(_lowerCAmelCase		,				_lowerCAmelCase   ):
                        if _add_into_out:
                              xa[i : i + chunk_size] += xa
                        else:
                              A_							       =		xa
            elif isinstance(_lowerCAmelCase		,				torch.Tensor   ):
                  if _add_into_out:
                        out[i : i + chunk_size] += output_chunk
                  else:
                        A_							       =		output_chunk
            else:
                  raise ValueError('''Not supported'''   )

            i += chunk_size

      A_							       =		tensor_tree_map(lambda SCREAMING_SNAKE_CASE   : t.view(orig_batch_dims + t.shape[1:]   )		,				_lowerCAmelCase   )

      return out





class    _lowercase				:

   def __init__(				self	:    Any			,						lowerCamelCase__	:    int = 5_1_2			,						) ->			List[Any]:
         """simple docstring"""





         A_							       =		max_chunk_size
         A_							       =		None
         A_							       =		None

   def     UpperCamelCase					(				self	:    List[Any]			,						lowerCamelCase__	:    Union[str, Any]			,						lowerCamelCase__	:    str			,						lowerCamelCase__	:    Dict       ) ->			Union[str, Any]:
         """simple docstring"""





         logging.info('''Tuning chunk size...'''       )

         if min_chunk_size >= self.max_chunk_size:
               return min_chunk_size

         A_							       =		[2**l for l in range(int(math.log(self.max_chunk_size			,						2       )       ) + 1       )]
         A_							       =		[c for c in candidates if c > min_chunk_size]
         A_							       =		[min_chunk_size] + candidates
         candidates[-1] += 4

         def test_chunk_size(lowerCamelCase__	:    Dict       ) -> bool:
               try:
                     with torch.no_grad():
                           fn(*A_			,						chunk_size=A_       )
                     return True
               except RuntimeError:
                     return False

         A_							       =		0
         A_							       =		len(A_       ) - 1
         while i > min_viable_chunk_size_index:
               A_							       =		test_chunk_size(candidates[i]       )
               if not viable:
                     A_							       =		(min_viable_chunk_size_index + i) // 2
               else:
                     A_							       =		i
                     A_							       =		(i + len(A_       ) - 1) // 2

         return candidates[min_viable_chunk_size_index]

   def     UpperCamelCase					(				self	:    Optional[int]			,						lowerCamelCase__	:    Tuple			,						lowerCamelCase__	:    List[Any]       ) ->			Union[str, Any]:
         """simple docstring"""





         A_							       =		True
         for aa, aa in zip(A_			,						A_       ):
               assert type(A_       ) == type(A_       )
               if isinstance(A_			,						(list, tuple)       ):
                     consistent &= self._compare_arg_caches(A_			,						A_       )
               elif isinstance(A_			,						A_       ):
                     A_							       =		[v for _, v in sorted(aa.items()			,						key=lambda lowerCamelCase__       : x[0]       )]
                     A_							       =		[v for _, v in sorted(aa.items()			,						key=lambda lowerCamelCase__       : x[0]       )]
                     consistent &= self._compare_arg_caches(A_			,						A_       )
               else:
                     consistent &= aa == aa

         return consistent





   def     UpperCamelCase					(				self	:    List[Any]			,						lowerCamelCase__	:    Tuple			,						lowerCamelCase__	:    Tuple			,						lowerCamelCase__	:    int			,						) ->			str:
         """simple docstring"""





         A_							       =		True
         A_							       =		tree_map(lambda lowerCamelCase__       : a.shape if isinstance(A_			,						torch.Tensor       ) else a			,						A_			,						A_       )
         if self.cached_arg_data is not None:
               # If args have changed shape/value, we need to re-tune
               assert len(self.cached_arg_data       ) == len(A_       )
               A_							       =		self._compare_arg_caches(self.cached_arg_data			,						A_       )
         else:
               # Otherwise, we can reuse the precomputed value
               A_							       =		False

         if not consistent:
               A_							       =		self._determine_favorable_chunk_size(
                   A_			,						A_			,						A_			,						)
               A_							       =		arg_data

         assert self.cached_chunk_size is not None

         return self.cached_chunk_size












import inspect
import math
import tempfile
import unittest

import numpy as np

from transformers import ViTMAEConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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 ViTMAEForPreTraining, ViTMAEModel
    from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import ViTImageProcessor



class    A__  :





      def __init__(					self			,				A_			,				A_=13			,				A_=30			,				A_=2			,				A_=3			,				A_=True			,				A_=True			,				A_=32			,				A_=5			,				A_=4			,				A_=37			,				A_="gelu"			,				A_=0.1			,				A_=0.1			,				A_=10			,				A_=0.02			,				A_=3			,				A_=0.6			,				A_=None			,				):
       '''simple docstring'''




       UpperCamelCase      :   Dict			      =  parent
       UpperCamelCase      :   Union[str, Any]			      =  batch_size
       UpperCamelCase      :   Any			      =  image_size
       UpperCamelCase      :   Tuple			      =  patch_size
       UpperCamelCase      :   Union[str, Any]			      =  num_channels
       UpperCamelCase      :   Tuple			      =  is_training
       UpperCamelCase      :   int			      =  use_labels
       UpperCamelCase      :   Tuple			      =  hidden_size
       UpperCamelCase      :   Optional[Any]			      =  num_hidden_layers
       UpperCamelCase      :   str			      =  num_attention_heads
       UpperCamelCase      :   Optional[int]			      =  intermediate_size
       UpperCamelCase      :   Dict			      =  hidden_act
       UpperCamelCase      :   List[str]			      =  hidden_dropout_prob
       UpperCamelCase      :   str			      =  attention_probs_dropout_prob
       UpperCamelCase      :   Optional[Any]			      =  type_sequence_label_size
       UpperCamelCase      :   Tuple			      =  initializer_range
       UpperCamelCase      :   Any			      =  mask_ratio
       UpperCamelCase      :   int			      =  scope

       # in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
       # (we add 1 for the [CLS] token)
       UpperCamelCase      :   Union[str, Any]			      =  (image_size // patch_size) ** 2
       UpperCamelCase      :   int			      =  int(math.ceil((1 - mask_ratio) * (num_patches + 1)  )  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Any			      =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

       UpperCamelCase      :   int			      =  None
       if self.use_labels:
        UpperCamelCase      :   Optional[Any]			      =  ids_tensor([self.batch_size]			,				self.type_sequence_label_size  )

       UpperCamelCase      :   str			      =  self.get_config()

       return config, pixel_values, labels





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       return ViTMAEConfig(
           image_size=self.image_size			,				patch_size=self.patch_size			,				num_channels=self.num_channels			,				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			,				is_decoder=A_			,				initializer_range=self.initializer_range			,				mask_ratio=self.mask_ratio			,				)





      def 			__UpperCamelCase(					self			,				A_			,				A_			,				A_  ):
       '''simple docstring'''




       UpperCamelCase      :   Any			      =  ViTMAEModel(config=A_  )
       model.to(A_  )
       model.eval()
       UpperCamelCase      :   Optional[Any]			      =  model(A_  )
       self.parent.assertEqual(result.last_hidden_state.shape			,				(self.batch_size, self.seq_length, self.hidden_size)  )





      def 			__UpperCamelCase(					self			,				A_			,				A_			,				A_  ):
       '''simple docstring'''




       UpperCamelCase      :   Tuple			      =  ViTMAEForPreTraining(A_  )
       model.to(A_  )
       model.eval()
       UpperCamelCase      :   List[str]			      =  model(A_  )
       UpperCamelCase      :   Any			      =  (self.image_size // self.patch_size) ** 2
       UpperCamelCase      :   List[str]			      =  self.patch_size**2 * self.num_channels
       self.parent.assertEqual(result.logits.shape			,				(self.batch_size, num_patches, expected_num_channels)  )

       # test greyscale images
       UpperCamelCase      :   str			      =  1
       UpperCamelCase      :   Union[str, Any]			      =  ViTMAEForPreTraining(A_  )
       model.to(A_  )
       model.eval()
       UpperCamelCase      :   Union[str, Any]			      =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
       UpperCamelCase      :   Union[str, Any]			      =  model(A_  )
       UpperCamelCase      :   List[str]			      =  self.patch_size**2
       self.parent.assertEqual(result.logits.shape			,				(self.batch_size, num_patches, expected_num_channels)  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Union[str, Any]			      =  self.prepare_config_and_inputs()
       UpperCamelCase      ,       UpperCamelCase      ,       UpperCamelCase      :   Optional[int]			      =  config_and_inputs
       UpperCamelCase      :   Optional[int]			      =  {"pixel_values": pixel_values}
       return config, inputs_dict



@require_torch
class    A__  (			__snake_case			,  __snake_case			,  unittest.TestCase     ):
      _UpperCAmelCase      :Any		       =  (ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else ()
      _UpperCAmelCase      :int		       =  {'feature-extraction': ViTMAEModel} if is_torch_available() else {}

      _UpperCAmelCase      :Optional[Any]		       =  False
      _UpperCAmelCase      :Any		       =  False
      _UpperCAmelCase      :Optional[int]		       =  False
      _UpperCAmelCase      :Dict		       =  False





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Union[str, Any]			      =  ViTMAEModelTester(self  )
       UpperCamelCase      :   Any			      =  ConfigTester(self			,				config_class=A_			,				has_text_modality=A_			,				hidden_size=37  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       self.config_tester.run_common_tests()





      @unittest.skip(reason="ViTMAE does not use inputs_embeds"  )
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       pass





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      ,       UpperCamelCase      :   List[Any]			      =  self.model_tester.prepare_config_and_inputs_for_common()

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





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      ,       UpperCamelCase      :   Optional[int]			      =  self.model_tester.prepare_config_and_inputs_for_common()

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

        UpperCamelCase      :   Optional[int]			      =  ["pixel_values"]
        self.assertListEqual(arg_names[:1]			,				A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   List[str]			      =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      :   Optional[int]			      =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_pretraining(*A_  )





      def 			__UpperCamelCase(					self			,				A_			,				A_			,				A_  ):
       '''simple docstring'''




       np.random.seed(2  )

       UpperCamelCase      :   Union[str, Any]			      =  int((pt_model.config.image_size // pt_model.config.patch_size) ** 2  )
       UpperCamelCase      :   Optional[Any]			      =  np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )
       UpperCamelCase      :   Tuple			      =  torch.from_numpy(A_  )

       # Add `noise` argument.
       # PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
       UpperCamelCase      :   Any			      =  pt_noise

       super().check_pt_tf_models(A_			,				A_			,				A_  )





      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       UpperCamelCase      ,       UpperCamelCase      :   Tuple			      =  self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
        UpperCamelCase      :   Optional[Any]			      =  model_class(A_  )
        model.to(A_  )
        model.eval()
        # make random mask reproducible
        torch.manual_seed(2  )
        with torch.no_grad():
         UpperCamelCase      :   str			      =  model(**self._prepare_for_class(A_			,				A_  )  )

        UpperCamelCase      :   Any			      =  outputs[0].cpu().numpy()
        UpperCamelCase      :   str			      =  0

        with tempfile.TemporaryDirectory() as tmpdirname:
         model.save_pretrained(A_  )
         UpperCamelCase      :   Optional[int]			      =  model_class.from_pretrained(A_  )
         model.to(A_  )
         # make random mask reproducible
         torch.manual_seed(2  )
         with torch.no_grad():
          UpperCamelCase      :   Tuple			      =  model(**self._prepare_for_class(A_			,				A_  )  )

         # Make sure we don't have nans
         UpperCamelCase      :   Dict			      =  after_outputs[0].cpu().numpy()
         UpperCamelCase      :   int			      =  0
         UpperCamelCase      :   str			      =  np.amax(np.abs(out_a - out_a  )  )
         self.assertLessEqual(A_			,				1e-5  )





      @unittest.skip(
          reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."  )
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       pass





      @unittest.skip(
          reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."  )
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       pass





      @unittest.skip(
          reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."  )
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       pass





      @unittest.skip(reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load"  )
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       pass





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




       pass





      @slow
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        UpperCamelCase      :   List[str]			      =  ViTMAEModel.from_pretrained(A_  )
        self.assertIsNotNone(A_  )



def 						A_							(	)		->					Optional[int]:
 UpperCamelCase      :   List[Any]			      =  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"	)
 return image



@require_torch
@require_vision
class    A__  (			unittest.TestCase     ):





      @cached_property
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       return ViTImageProcessor.from_pretrained("facebook/vit-mae-base"  ) if is_vision_available() else None





      @slow
      def 			__UpperCamelCase(					self  ):
       '''simple docstring'''




       np.random.seed(2  )

       UpperCamelCase      :   Union[str, Any]			      =  ViTMAEForPreTraining.from_pretrained("facebook/vit-mae-base"  ).to(A_  )

       UpperCamelCase      :   Any			      =  self.default_image_processor
       UpperCamelCase      :   Optional[Any]			      =  prepare_img()
       UpperCamelCase      :   int			      =  image_processor(images=A_			,				return_tensors="pt"  ).to(A_  )

       # prepare a noise vector that will be also used for testing the TF model
       # (this way we can ensure that the PT and TF models operate on the same inputs)
       UpperCamelCase      :   Dict			      =  ViTMAEConfig()
       UpperCamelCase      :   Any			      =  int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2  )
       UpperCamelCase      :   Optional[Any]			      =  np.random.uniform(size=(1, num_patches)  )

       # forward pass
       with torch.no_grad():
        UpperCamelCase      :   Optional[Any]			      =  model(**A_			,				noise=torch.from_numpy(A_  ).to(device=A_  )  )

       # verify the logits
       UpperCamelCase      :   str			      =  torch.Size((1, 196, 768)  )
       self.assertEqual(outputs.logits.shape			,				A_  )

       UpperCamelCase      :   str			      =  torch.tensor(
           [[-0.05_48, -1.70_23, -0.93_25], [0.37_21, -0.56_70, -0.22_33], [0.82_35, -1.38_78, -0.35_24]]  )

       self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]			,				expected_slice.to(A_  )			,				atol=1e-4  )  )
