






'''simple docstring'''







from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
)




@flax.struct.dataclass
class 		UpperCamelCase__    (a			):




		'''simple docstring'''





		_UpperCamelCase				  =    42
		_UpperCamelCase				  =    42




class 		UpperCamelCase__    (nn.Module			):




		'''simple docstring'''





		_UpperCamelCase				  =    42
		_UpperCamelCase				  =    (16, 32, 96, 256)
		_UpperCamelCase				  =    jnp.floataa






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  nn.Conv(
								    self.block_out_channels[0]   ,kernel_size=(3, 3)   ,padding=((1, 1), (1, 1))   ,dtype=self.dtype   ,)

								lowerCamelCase__         =  []
								for i in range(len(self.block_out_channels       ) - 1       ):
														lowerCamelCase__         =  self.block_out_channels[i]
														lowerCamelCase__         =  self.block_out_channels[i + 1]
														lowerCamelCase__         =  nn.Conv(
														    _lowerCAmelCase   ,kernel_size=(3, 3)   ,padding=((1, 1), (1, 1))   ,dtype=self.dtype   ,)
														blocks.append(_lowerCAmelCase       )
														lowerCamelCase__         =  nn.Conv(
														    _lowerCAmelCase   ,kernel_size=(3, 3)   ,strides=(2, 2)   ,padding=((1, 1), (1, 1))   ,dtype=self.dtype   ,)
														blocks.append(_lowerCAmelCase       )
								lowerCamelCase__         =  blocks

								lowerCamelCase__         =  nn.Conv(
								    self.conditioning_embedding_channels   ,kernel_size=(3, 3)   ,padding=((1, 1), (1, 1))   ,kernel_init=nn.initializers.zeros_init()   ,bias_init=nn.initializers.zeros_init()   ,dtype=self.dtype   ,)






		def __call__(      self   ,_lowerCAmelCase       ):
								lowerCamelCase__         =  self.conv_in(_lowerCAmelCase       )
								lowerCamelCase__         =  nn.silu(_lowerCAmelCase       )

								for block in self.blocks:
														lowerCamelCase__         =  block(_lowerCAmelCase       )
														lowerCamelCase__         =  nn.silu(_lowerCAmelCase       )

								lowerCamelCase__         =  self.conv_out(_lowerCAmelCase       )

								return embedding




@flax_register_to_config
class 		UpperCamelCase__    (nn.Module   ,a   ,a			):




		'''simple docstring'''





		_UpperCamelCase				  =    32
		_UpperCamelCase				  =    4
		_UpperCamelCase				  =    (
		    'CrossAttnDownBlock2D',
		    'CrossAttnDownBlock2D',
		    'CrossAttnDownBlock2D',
		    'DownBlock2D',
		)
		_UpperCamelCase				  =    False
		_UpperCamelCase				  =    (320, 640, 1280, 1280)
		_UpperCamelCase				  =    2
		_UpperCamelCase				  =    8
		_UpperCamelCase				  =    None
		_UpperCamelCase				  =    1280
		_UpperCamelCase				  =    0.0
		_UpperCamelCase				  =    False
		_UpperCamelCase				  =    jnp.floataa
		_UpperCamelCase				  =    True
		_UpperCamelCase				  =    0
		_UpperCamelCase				  =    'rgb'
		_UpperCamelCase				  =    (16, 32, 96, 256)






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase       ):
								# init input tensors
								lowerCamelCase__         =  (1, self.in_channels, self.sample_size, self.sample_size)
								lowerCamelCase__         =  jnp.zeros(_lowerCAmelCase   ,dtype=jnp.floataa       )
								lowerCamelCase__         =  jnp.ones((1,)   ,dtype=jnp.intaa       )
								lowerCamelCase__         =  jnp.zeros((1, 1, self.cross_attention_dim)   ,dtype=jnp.floataa       )
								lowerCamelCase__         =  (1, 3, self.sample_size * 8, self.sample_size * 8)
								lowerCamelCase__         =  jnp.zeros(_lowerCAmelCase   ,dtype=jnp.floataa       )

								lowerCamelCase__       ,			lowerCamelCase__         =  jax.random.split(_lowerCAmelCase       )
								lowerCamelCase__         =  {"""params""": params_rng, """dropout""": dropout_rng}

								return self.init(_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       )["params"]






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.block_out_channels
								lowerCamelCase__         =  block_out_channels[0] * 4

								# If `num_attention_heads` is not defined (which is the case for most models)
								# it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
								# The reason for this behavior is to correct for incorrectly named variables that were introduced
								# when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
								# Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
								# which is why we correct for the naming here.
								lowerCamelCase__         =  self.num_attention_heads or self.attention_head_dim

								# input
								lowerCamelCase__         =  nn.Conv(
								    block_out_channels[0]   ,kernel_size=(3, 3)   ,strides=(1, 1)   ,padding=((1, 1), (1, 1))   ,dtype=self.dtype   ,)

								# time
								lowerCamelCase__         =  FlaxTimesteps(
								    block_out_channels[0]   ,flip_sin_to_cos=self.flip_sin_to_cos   ,freq_shift=self.config.freq_shift       )
								lowerCamelCase__         =  FlaxTimestepEmbedding(_lowerCAmelCase   ,dtype=self.dtype       )

								lowerCamelCase__         =  FlaxControlNetConditioningEmbedding(
								    conditioning_embedding_channels=block_out_channels[0]   ,block_out_channels=self.conditioning_embedding_out_channels   ,)

								lowerCamelCase__         =  self.only_cross_attention
								if isinstance(_lowerCAmelCase   ,_lowerCAmelCase       ):
														lowerCamelCase__         =  (only_cross_attention,) * len(self.down_block_types       )

								if isinstance(_lowerCAmelCase   ,_lowerCAmelCase       ):
														lowerCamelCase__         =  (num_attention_heads,) * len(self.down_block_types       )

								# down
								lowerCamelCase__         =  []
								lowerCamelCase__         =  []

								lowerCamelCase__         =  block_out_channels[0]

								lowerCamelCase__         =  nn.Conv(
								    _lowerCAmelCase   ,kernel_size=(1, 1)   ,padding="""VALID"""   ,kernel_init=nn.initializers.zeros_init()   ,bias_init=nn.initializers.zeros_init()   ,dtype=self.dtype   ,)
								controlnet_down_blocks.append(_lowerCAmelCase       )

								for i, down_block_type in enumerate(self.down_block_types       ):
														lowerCamelCase__         =  output_channel
														lowerCamelCase__         =  block_out_channels[i]
														lowerCamelCase__         =  i == len(_lowerCAmelCase       ) - 1

														if down_block_type == "CrossAttnDownBlock2D":
																				lowerCamelCase__         =  FlaxCrossAttnDownBlockaD(
																				    in_channels=_lowerCAmelCase   ,out_channels=_lowerCAmelCase   ,dropout=self.dropout   ,num_layers=self.layers_per_block   ,num_attention_heads=num_attention_heads[i]   ,add_downsample=not is_final_block   ,use_linear_projection=self.use_linear_projection   ,only_cross_attention=only_cross_attention[i]   ,dtype=self.dtype   ,)
														else:
																				lowerCamelCase__         =  FlaxDownBlockaD(
																				    in_channels=_lowerCAmelCase   ,out_channels=_lowerCAmelCase   ,dropout=self.dropout   ,num_layers=self.layers_per_block   ,add_downsample=not is_final_block   ,dtype=self.dtype   ,)

														down_blocks.append(_lowerCAmelCase       )

														for _ in range(self.layers_per_block       ):
																				lowerCamelCase__         =  nn.Conv(
																				    _lowerCAmelCase   ,kernel_size=(1, 1)   ,padding="""VALID"""   ,kernel_init=nn.initializers.zeros_init()   ,bias_init=nn.initializers.zeros_init()   ,dtype=self.dtype   ,)
																				controlnet_down_blocks.append(_lowerCAmelCase       )

														if not is_final_block:
																				lowerCamelCase__         =  nn.Conv(
																				    _lowerCAmelCase   ,kernel_size=(1, 1)   ,padding="""VALID"""   ,kernel_init=nn.initializers.zeros_init()   ,bias_init=nn.initializers.zeros_init()   ,dtype=self.dtype   ,)
																				controlnet_down_blocks.append(_lowerCAmelCase       )

								lowerCamelCase__         =  down_blocks
								lowerCamelCase__         =  controlnet_down_blocks

								# mid
								lowerCamelCase__         =  block_out_channels[-1]
								lowerCamelCase__         =  FlaxUNetMidBlockaDCrossAttn(
								    in_channels=_lowerCAmelCase   ,dropout=self.dropout   ,num_attention_heads=num_attention_heads[-1]   ,use_linear_projection=self.use_linear_projection   ,dtype=self.dtype   ,)

								lowerCamelCase__         =  nn.Conv(
								    _lowerCAmelCase   ,kernel_size=(1, 1)   ,padding="""VALID"""   ,kernel_init=nn.initializers.zeros_init()   ,bias_init=nn.initializers.zeros_init()   ,dtype=self.dtype   ,)






		def __call__(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase = 1.0   ,_lowerCAmelCase = True   ,_lowerCAmelCase = False   ,):
								lowerCamelCase__         =  self.controlnet_conditioning_channel_order
								if channel_order == "bgr":
														lowerCamelCase__         =  jnp.flip(_lowerCAmelCase   ,axis=1       )

								# 1. time
								if not isinstance(_lowerCAmelCase   ,jnp.ndarray       ):
														lowerCamelCase__         =  jnp.array([timesteps]   ,dtype=jnp.intaa       )
								elif isinstance(_lowerCAmelCase   ,jnp.ndarray       ) and len(timesteps.shape       ) == 0:
														lowerCamelCase__         =  timesteps.astype(dtype=jnp.floataa       )
														lowerCamelCase__         =  jnp.expand_dims(_lowerCAmelCase   ,0       )

								lowerCamelCase__         =  self.time_proj(_lowerCAmelCase       )
								lowerCamelCase__         =  self.time_embedding(_lowerCAmelCase       )

								# 2. pre-process
								lowerCamelCase__         =  jnp.transpose(_lowerCAmelCase   ,(0, 2, 3, 1)       )
								lowerCamelCase__         =  self.conv_in(_lowerCAmelCase       )

								lowerCamelCase__         =  jnp.transpose(_lowerCAmelCase   ,(0, 2, 3, 1)       )
								lowerCamelCase__         =  self.controlnet_cond_embedding(_lowerCAmelCase       )
								sample += controlnet_cond

								# 3. down
								lowerCamelCase__         =  (sample,)
								for down_block in self.down_blocks:
														if isinstance(_lowerCAmelCase   ,_lowerCAmelCase       ):
																				lowerCamelCase__       ,			lowerCamelCase__         =  down_block(_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase   ,deterministic=not train       )
														else:
																				lowerCamelCase__       ,			lowerCamelCase__         =  down_block(_lowerCAmelCase   ,_lowerCAmelCase   ,deterministic=not train       )
														down_block_res_samples += res_samples

								# 4. mid
								lowerCamelCase__         =  self.mid_block(_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase   ,deterministic=not train       )

								# 5. contronet blocks
								lowerCamelCase__         =  ()
								for down_block_res_sample, controlnet_block in zip(_lowerCAmelCase   ,self.controlnet_down_blocks       ):
														lowerCamelCase__         =  controlnet_block(_lowerCAmelCase       )
														controlnet_down_block_res_samples += (down_block_res_sample,)

								lowerCamelCase__         =  controlnet_down_block_res_samples

								lowerCamelCase__         =  self.controlnet_mid_block(_lowerCAmelCase       )

								# 6. scaling
								lowerCamelCase__         =  [sample * conditioning_scale for sample in down_block_res_samples]
								mid_block_res_sample *= conditioning_scale

								if not return_dict:
														return (down_block_res_samples, mid_block_res_sample)

								return FlaxControlNetOutput(
								    down_block_res_samples=_lowerCAmelCase   ,mid_block_res_sample=_lowerCAmelCase       )









'''simple docstring'''







from __future__ import annotations

import copy
import inspect
import json
import math
import os
import tempfile
import unittest
from importlib import import_module

import numpy as np

from transformers import ViTMAEConfig
from transformers.file_utils import cached_property, is_tf_available, is_vision_available
from transformers.testing_utils import require_tf, require_vision, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import TFViTMAEForPreTraining, TFViTMAEModel


if is_vision_available():
							from PIL import Image

							from transformers import ViTImageProcessor




class 		UpperCamelCase__    :




		'''simple docstring'''





		def __init__(      self   ,_lowerCAmelCase   ,_lowerCAmelCase=13   ,_lowerCAmelCase=30   ,_lowerCAmelCase=2   ,_lowerCAmelCase=3   ,_lowerCAmelCase=True   ,_lowerCAmelCase=True   ,_lowerCAmelCase=32   ,_lowerCAmelCase=2   ,_lowerCAmelCase=4   ,_lowerCAmelCase=37   ,_lowerCAmelCase="gelu"   ,_lowerCAmelCase=0.1   ,_lowerCAmelCase=0.1   ,_lowerCAmelCase=10   ,_lowerCAmelCase=0.02   ,_lowerCAmelCase=3   ,_lowerCAmelCase=0.6   ,_lowerCAmelCase=None   ,):
								lowerCamelCase__         =  parent
								lowerCamelCase__         =  batch_size
								lowerCamelCase__         =  image_size
								lowerCamelCase__         =  patch_size
								lowerCamelCase__         =  num_channels
								lowerCamelCase__         =  is_training
								lowerCamelCase__         =  use_labels
								lowerCamelCase__         =  hidden_size
								lowerCamelCase__         =  num_hidden_layers
								lowerCamelCase__         =  num_attention_heads
								lowerCamelCase__         =  intermediate_size
								lowerCamelCase__         =  hidden_act
								lowerCamelCase__         =  hidden_dropout_prob
								lowerCamelCase__         =  attention_probs_dropout_prob
								lowerCamelCase__         =  type_sequence_label_size
								lowerCamelCase__         =  initializer_range
								lowerCamelCase__         =  mask_ratio
								lowerCamelCase__         =  scope

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






		def 			UpperCamelCase_					(      self       ):
								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 			UpperCamelCase_					(      self       ):
								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   ,decoder_hidden_size=self.hidden_size   ,decoder_num_hidden_layers=self.num_hidden_layers   ,decoder_num_attention_heads=self.num_attention_heads   ,decoder_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=_lowerCAmelCase   ,initializer_range=self.initializer_range   ,mask_ratio=self.mask_ratio   ,)






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								lowerCamelCase__         =  TFViTMAEModel(config=_lowerCAmelCase       )
								lowerCamelCase__         =  model(_lowerCAmelCase   ,training=_lowerCAmelCase       )
								self.parent.assertEqual(result.last_hidden_state.shape   ,(self.batch_size, self.seq_length, self.hidden_size)       )






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								lowerCamelCase__         =  TFViTMAEForPreTraining(_lowerCAmelCase       )
								lowerCamelCase__         =  model(_lowerCAmelCase   ,training=_lowerCAmelCase       )
								# expected sequence length = num_patches
								lowerCamelCase__         =  (self.image_size // self.patch_size) ** 2
								lowerCamelCase__         =  self.patch_size**2 * self.num_channels
								self.parent.assertEqual(result.logits.shape   ,(self.batch_size, num_patches, expected_num_channels)       )

								# test greyscale images
								lowerCamelCase__         =  1
								lowerCamelCase__         =  TFViTMAEForPreTraining(_lowerCAmelCase       )

								lowerCamelCase__         =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
								lowerCamelCase__         =  model(_lowerCAmelCase   ,training=_lowerCAmelCase       )
								lowerCamelCase__         =  self.patch_size**2
								self.parent.assertEqual(result.logits.shape   ,(self.batch_size, num_patches, expected_num_channels)       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.prepare_config_and_inputs()
								((lowerCamelCase__)       ,			(lowerCamelCase__)       ,			(lowerCamelCase__))         =  config_and_inputs
								lowerCamelCase__         =  {"""pixel_values""": pixel_values}
								return config, inputs_dict




@require_tf
class 		UpperCamelCase__    (a   ,a   ,unittest.TestCase			):




		'''simple docstring'''





		_UpperCamelCase				  =					(TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
		_UpperCamelCase				  =					{'feature-extraction': TFViTMAEModel} if is_tf_available() else {}

		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False
		_UpperCamelCase				  =					False






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  TFViTMAEModelTester(self       )
								lowerCamelCase__         =  ConfigTester(self   ,config_class=_lowerCAmelCase   ,has_text_modality=_lowerCAmelCase   ,hidden_size=37       )






		def 			UpperCamelCase_					(      self       ):
								self.config_tester.run_common_tests()






		@unittest.skip(reason="""ViTMAE does not use inputs_embeds"""       )
		def 			UpperCamelCase_					(      self       ):
								pass






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														lowerCamelCase__         =  model_class(_lowerCAmelCase       )
														self.assertIsInstance(model.get_input_embeddings()   ,(tf.keras.layers.Layer)       )
														lowerCamelCase__         =  model.get_output_embeddings()
														self.assertTrue(x is None or isinstance(_lowerCAmelCase   ,tf.keras.layers.Layer       )       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

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

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






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_pretraining(*_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								# make the mask reproducible
								np.random.seed(2       )

								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

								lowerCamelCase__         =  int((config.image_size // config.patch_size) ** 2       )
								lowerCamelCase__         =  np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )

								for model_class in self.all_model_classes:
														lowerCamelCase__         =  model_class(_lowerCAmelCase       )
														lowerCamelCase__         =  self._prepare_for_class(_lowerCAmelCase   ,_lowerCAmelCase       )

														lowerCamelCase__         =  model(_lowerCAmelCase   ,noise=_lowerCAmelCase       )

														lowerCamelCase__         =  copy.deepcopy(self._prepare_for_class(_lowerCAmelCase   ,_lowerCAmelCase       )       )
														lowerCamelCase__         =  model(**_lowerCAmelCase   ,noise=_lowerCAmelCase       )
														lowerCamelCase__         =  outputs_dict[0].numpy()
														lowerCamelCase__         =  outputs_keywords[0].numpy()

														self.assertLess(np.sum(np.abs(output_dict - output_keywords       )       )   ,1E-6       )






		def 			UpperCamelCase_					(      self       ):
								# make the mask reproducible
								np.random.seed(2       )

								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

								lowerCamelCase__         =  int((config.image_size // config.patch_size) ** 2       )
								lowerCamelCase__         =  np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )

								def prepare_numpy_arrays(_lowerCAmelCase       ):
														lowerCamelCase__         =  {}
														for k, v in inputs_dict.items():
																				if tf.is_tensor(_lowerCAmelCase       ):
																										lowerCamelCase__         =  v.numpy()
																				else:
																										lowerCamelCase__         =  np.array(_lowerCAmelCase       )

														return inputs_np_dict

								for model_class in self.all_model_classes:
														lowerCamelCase__         =  model_class(_lowerCAmelCase       )

														lowerCamelCase__         =  self._prepare_for_class(_lowerCAmelCase   ,_lowerCAmelCase       )
														lowerCamelCase__         =  prepare_numpy_arrays(_lowerCAmelCase       )

														lowerCamelCase__         =  model(_lowerCAmelCase   ,noise=_lowerCAmelCase       )
														lowerCamelCase__         =  model(**_lowerCAmelCase   ,noise=_lowerCAmelCase       )
														self.assert_outputs_same(_lowerCAmelCase   ,_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								# make masks reproducible
								np.random.seed(2       )

								lowerCamelCase__         =  int((tf_model.config.image_size // tf_model.config.patch_size) ** 2       )
								lowerCamelCase__         =  np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )
								lowerCamelCase__         =  tf.constant(_lowerCAmelCase       )

								# Add `noise` argument.
								# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
								lowerCamelCase__         =  tf_noise

								super().check_pt_tf_models(_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								# make mask reproducible
								np.random.seed(2       )

								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

								lowerCamelCase__         =  {
								    module_member
								    for model_class in self.all_model_classes
								    for module in (import_module(model_class.__module__       ),)
								    for module_member_name in dir(_lowerCAmelCase       )
								    if module_member_name.endswith("""MainLayer"""       )
								    # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`.
								    and module_member_name[: -len("""MainLayer"""       )] == model_class.__name__[: -len("""Model"""       )]
								    for module_member in (getattr(_lowerCAmelCase   ,_lowerCAmelCase       ),)
								    if isinstance(_lowerCAmelCase   ,_lowerCAmelCase       )
								    and tf.keras.layers.Layer in module_member.__bases__
								    and getattr(_lowerCAmelCase   ,"""_keras_serializable"""   ,_lowerCAmelCase       )
								}

								lowerCamelCase__         =  int((config.image_size // config.patch_size) ** 2       )
								lowerCamelCase__         =  np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )
								lowerCamelCase__         =  tf.convert_to_tensor(_lowerCAmelCase       )
								inputs_dict.update({"""noise""": noise}       )

								for main_layer_class in tf_main_layer_classes:
														lowerCamelCase__         =  main_layer_class(_lowerCAmelCase       )

														lowerCamelCase__         =  {
														    name: tf.keras.Input(tensor.shape[1:]   ,dtype=tensor.dtype       ) for name, tensor in inputs_dict.items()
														}

														lowerCamelCase__         =  tf.keras.Model(_lowerCAmelCase   ,outputs=main_layer(_lowerCAmelCase       )       )
														lowerCamelCase__         =  model(_lowerCAmelCase       )

														with tempfile.TemporaryDirectory() as tmpdirname:
																				lowerCamelCase__         =  os.path.join(_lowerCAmelCase   ,"""keras_model.h5"""       )
																				model.save(_lowerCAmelCase       )
																				lowerCamelCase__         =  tf.keras.models.load_model(
																				    _lowerCAmelCase   ,custom_objects={main_layer_class.__name__: main_layer_class}       )
																				assert isinstance(_lowerCAmelCase   ,tf.keras.Model       )
																				lowerCamelCase__         =  model(_lowerCAmelCase       )
																				self.assert_outputs_same(_lowerCAmelCase   ,_lowerCAmelCase       )






		@slow
		def 			UpperCamelCase_					(      self       ):
								# make mask reproducible
								np.random.seed(2       )

								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

								lowerCamelCase__         =  int((config.image_size // config.patch_size) ** 2       )
								lowerCamelCase__         =  np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )

								for model_class in self.all_model_classes:
														lowerCamelCase__         =  model_class(_lowerCAmelCase       )
														lowerCamelCase__         =  self._prepare_for_class(_lowerCAmelCase   ,_lowerCAmelCase       )
														lowerCamelCase__         =  model(_lowerCAmelCase   ,noise=_lowerCAmelCase       )

														if model_class.__name__ == "TFViTMAEModel":
																				lowerCamelCase__         =  outputs.last_hidden_state.numpy()
																				lowerCamelCase__         =  0
														else:
																				lowerCamelCase__         =  outputs.logits.numpy()
																				lowerCamelCase__         =  0

														with tempfile.TemporaryDirectory() as tmpdirname:
																				model.save_pretrained(_lowerCAmelCase   ,saved_model=_lowerCAmelCase       )
																				lowerCamelCase__         =  model_class.from_pretrained(_lowerCAmelCase       )
																				lowerCamelCase__         =  model(_lowerCAmelCase   ,noise=_lowerCAmelCase       )

																				if model_class.__name__ == "TFViTMAEModel":
																										lowerCamelCase__         =  after_outputs["""last_hidden_state"""].numpy()
																										lowerCamelCase__         =  0
																				else:
																										lowerCamelCase__         =  after_outputs["""logits"""].numpy()
																										lowerCamelCase__         =  0

																				lowerCamelCase__         =  np.amax(np.abs(out_a - out_a       )       )
																				self.assertLessEqual(_lowerCAmelCase   ,1E-5       )






		def 			UpperCamelCase_					(      self       ):
								# make mask reproducible
								np.random.seed(2       )

								lowerCamelCase__       ,			lowerCamelCase__         =  self.model_tester.prepare_config_and_inputs_for_common()

								lowerCamelCase__         =  int((config.image_size // config.patch_size) ** 2       )
								lowerCamelCase__         =  np.random.uniform(size=(self.model_tester.batch_size, num_patches)       )

								for model_class in self.all_model_classes:
														lowerCamelCase__         =  model_class(_lowerCAmelCase       )
														lowerCamelCase__         =  self._prepare_for_class(_lowerCAmelCase   ,_lowerCAmelCase       )

														lowerCamelCase__         =  model(_lowerCAmelCase   ,noise=_lowerCAmelCase       )
														lowerCamelCase__         =  model.get_config()
														# make sure that returned config is jsonifiable, which is required by keras
														json.dumps(_lowerCAmelCase       )
														lowerCamelCase__         =  model_class.from_config(model.get_config()       )
														# make sure it also accepts a normal config
														lowerCamelCase__         =  model_class.from_config(model.config       )
														lowerCamelCase__         =  new_model(_lowerCAmelCase       )  # Build model
														new_model.set_weights(model.get_weights()       )
														lowerCamelCase__         =  new_model(_lowerCAmelCase   ,noise=_lowerCAmelCase       )

														self.assert_outputs_same(_lowerCAmelCase   ,_lowerCAmelCase       )






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






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






		@slow
		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  TFViTMAEModel.from_pretrained("""google/vit-base-patch16-224"""       )
								self.assertIsNotNone(_lowerCAmelCase       )



def 						A__			(				):
						lowerCamelCase__         =  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
						return image





@require_tf
@require_vision
class 		UpperCamelCase__    (unittest.TestCase			):




		'''simple docstring'''





		@cached_property
		def 			UpperCamelCase_					(      self       ):
								return ViTImageProcessor.from_pretrained("""facebook/vit-mae-base"""       ) if is_vision_available() else None






		@slow
		def 			UpperCamelCase_					(      self       ):
								# make random mask reproducible across the PT and TF model
								np.random.seed(2       )

								lowerCamelCase__         =  TFViTMAEForPreTraining.from_pretrained("""facebook/vit-mae-base"""       )

								lowerCamelCase__         =  self.default_image_processor
								lowerCamelCase__         =  prepare_img()
								lowerCamelCase__         =  image_processor(images=_lowerCAmelCase   ,return_tensors="""tf"""       )

								# 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)
								lowerCamelCase__         =  ViTMAEConfig()
								lowerCamelCase__         =  int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2       )
								lowerCamelCase__         =  np.random.uniform(size=(1, num_patches)       )

								# forward pass
								lowerCamelCase__         =  model(**_lowerCAmelCase   ,noise=_lowerCAmelCase       )

								# verify the logits
								lowerCamelCase__         =  tf.convert_to_tensor([1, 1_96, 7_68]       )
								self.assertEqual(outputs.logits.shape   ,_lowerCAmelCase       )

								lowerCamelCase__         =  tf.convert_to_tensor(
								    [[-0.0548, -1.7023, -0.9325], [0.3721, -0.5670, -0.2233], [0.8235, -1.3878, -0.3524]]       )

								tf.debugging.assert_near(outputs.logits[0, :3, :3]   ,_lowerCAmelCase   ,atol=1E-4       )

