

from sklearn.metrics import recall_score

import datasets


_a:    Optional[int] 							=			"""
Recall is the fraction of the positive examples that were correctly labeled by the model as positive. It can be computed with the equation:
Recall = TP / (TP + FN)
Where TP is the true positives and FN is the false negatives.
"""


_a:    Dict 							=			"""
Args:
- **predictions** (`list` of `int`): The predicted labels.
- **references** (`list` of `int`): The ground truth labels.
- **labels** (`list` of `int`): The set of labels to include when `average` is not set to `binary`, and their order when average is `None`. Labels present in the data can be excluded in this input, for example to calculate a multiclass average ignoring a majority negative class, while labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in y_true and y_pred are used in sorted order. Defaults to None.
- **pos_label** (`int`): The class label to use as the 'positive class' when calculating the recall. Defaults to `1`.
- **average** (`string`): This parameter is required for multiclass/multilabel targets. If None, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `'binary'`.
    - `'binary'`: Only report results for the class specified by `pos_label`. This is applicable only if the target labels and predictions are binary.
    - `'micro'`: Calculate metrics globally by counting the total true positives, false negatives, and false positives.
    - `'macro'`: Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.
    - `'weighted'`: Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `'macro'` to account for label imbalance. Note that it can result in an F-score that is not between precision and recall.
    - `'samples'`: Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).
- **sample_weight** (`list` of `float`): Sample weights Defaults to `None`.
- **zero_division** (): Sets the value to return when there is a zero division. Defaults to .
    - `'warn'`: If there is a zero division, the return value is `0`, but warnings are also raised.
    - `0`: If there is a zero division, the return value is `0`.
    - `1`: If there is a zero division, the return value is `1`.

Returns:
- **recall** (`float`, or `array` of `float`): Either the general recall score, or the recall scores for individual classes, depending on the values input to `labels` and `average`. Minimum possible value is 0. Maximum possible value is 1. A higher recall means that more of the positive examples have been labeled correctly. Therefore, a higher recall is generally considered better.

Examples:

    Example 1-A simple example with some errors
        >>> recall_metric = datasets.load_metric('recall')
        >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1])
        >>> print(results)
        {'recall': 0.6666666666666666}

    Example 2-The same example as Example 1, but with `pos_label=0` instead of the default `pos_label=1`.
        >>> recall_metric = datasets.load_metric('recall')
        >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1], pos_label=0)
        >>> print(results)
        {'recall': 0.5}

    Example 3-The same example as Example 1, but with `sample_weight` included.
        >>> recall_metric = datasets.load_metric('recall')
        >>> sample_weight = [0.9, 0.2, 0.9, 0.3, 0.8]
        >>> results = recall_metric.compute(references=[0, 0, 1, 1, 1], predictions=[0, 1, 0, 1, 1], sample_weight=sample_weight)
        >>> print(results)
        {'recall': 0.55}

    Example 4-A multiclass example, using different averages.
        >>> recall_metric = datasets.load_metric('recall')
        >>> predictions = [0, 2, 1, 0, 0, 1]
        >>> references = [0, 1, 2, 0, 1, 2]
        >>> results = recall_metric.compute(predictions=predictions, references=references, average='macro')
        >>> print(results)
        {'recall': 0.3333333333333333}
        >>> results = recall_metric.compute(predictions=predictions, references=references, average='micro')
        >>> print(results)
        {'recall': 0.3333333333333333}
        >>> results = recall_metric.compute(predictions=predictions, references=references, average='weighted')
        >>> print(results)
        {'recall': 0.3333333333333333}
        >>> results = recall_metric.compute(predictions=predictions, references=references, average=None)
        >>> print(results)
        {'recall': array([1., 0., 0.])}
"""


_a:    str 							=			"""
@article{scikit-learn, title={Scikit-learn: Machine Learning in {P}ython}, author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V. and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P. and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.}, journal={Journal of Machine Learning Research}, volume={12}, pages={2825--2830}, year={2011}
"""

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION     ,     _KWARGS_DESCRIPTION						)
class 						__UpperCamelCase    (					datasets.Metric						):




	def       __A					(		self	:						List[Any]							):


		'''simple docstring'''







		return datasets.MetricInfo(
		    description=_DESCRIPTION		,	citation=_CITATION		,	inputs_description=_KWARGS_DESCRIPTION		,	features=datasets.Features(
		        {
		            "predictions": datasets.Sequence(datasets.Value("int32"							)							),
		            "references": datasets.Sequence(datasets.Value("int32"							)							),
		        }
		        if self.config_name == "multilabel"
		        else {
		            "predictions": datasets.Value("int32"							),
		            "references": datasets.Value("int32"							),
		        }							)		,	reference_urls=["https://scikit-learn.org/stable/modules/generated/sklearn.metrics.recall_score.html"]		,	)




	def       __A					(		self	:						Any		,	lowerCAmelCase	:						Any		,	lowerCAmelCase	:						Union[str, Any]		,	lowerCAmelCase	:						Tuple=None		,	lowerCAmelCase	:						Any=1		,	lowerCAmelCase	:						str="binary"		,	lowerCAmelCase	:						Optional[int]=None		,	lowerCAmelCase	:						Any="warn"		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			recall_score(
		    lowerCAmelCase		,	lowerCAmelCase		,	labels=lowerCAmelCase		,	pos_label=lowerCAmelCase		,	average=lowerCAmelCase		,	sample_weight=lowerCAmelCase		,	zero_division=lowerCAmelCase		,	)
		return {"recall": float(lowerCAmelCase							) if score.size == 1 else score}


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    :




	def __init__(		self	:						str		,	lowerCAmelCase	:						List[str]		,	lowerCAmelCase	:						List[str]=13		,	lowerCAmelCase	:						Optional[int]=30		,	lowerCAmelCase	:						Tuple=2		,	lowerCAmelCase	:						List[Any]=3		,	lowerCAmelCase	:						Any=True		,	lowerCAmelCase	:						Optional[int]=True		,	lowerCAmelCase	:						Any=32		,	lowerCAmelCase	:						Union[str, Any]=2		,	lowerCAmelCase	:						str=4		,	lowerCAmelCase	:						Tuple=37		,	lowerCAmelCase	:						Optional[int]="gelu"		,	lowerCAmelCase	:						Dict=0.1		,	lowerCAmelCase	:						str=0.1		,	lowerCAmelCase	:						List[Any]=10		,	lowerCAmelCase	:						Union[str, Any]=0.02		,	lowerCAmelCase	:						Tuple=3		,	lowerCAmelCase	:						List[Any]=0.6		,	lowerCAmelCase	:						List[Any]=None		,	):


		'''simple docstring'''







		UpperCAmelCase_       				=			parent
		UpperCAmelCase_       				=			batch_size
		UpperCAmelCase_       				=			image_size
		UpperCAmelCase_       				=			patch_size
		UpperCAmelCase_       				=			num_channels
		UpperCAmelCase_       				=			is_training
		UpperCAmelCase_       				=			use_labels
		UpperCAmelCase_       				=			hidden_size
		UpperCAmelCase_       				=			num_hidden_layers
		UpperCAmelCase_       				=			num_attention_heads
		UpperCAmelCase_       				=			intermediate_size
		UpperCAmelCase_       				=			hidden_act
		UpperCAmelCase_       				=			hidden_dropout_prob
		UpperCAmelCase_       				=			attention_probs_dropout_prob
		UpperCAmelCase_       				=			type_sequence_label_size
		UpperCAmelCase_       				=			initializer_range
		UpperCAmelCase_       				=			mask_ratio
		UpperCAmelCase_       				=			scope

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




	def       __A					(		self	:						Any							):


		'''simple docstring'''







		UpperCAmelCase_       				=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

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

		UpperCAmelCase_       				=			self.get_config()

		return config, pixel_values, labels




	def       __A					(		self	:						Optional[Any]							):


		'''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		,	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       __A					(		self	:						List[str]		,	lowerCAmelCase	:						Any		,	lowerCAmelCase	:						List[Any]		,	lowerCAmelCase	:						Dict							):


		'''simple docstring'''







		UpperCAmelCase_       				=			TFViTMAEModel(config=lowerCAmelCase							)
		UpperCAmelCase_       				=			model(lowerCAmelCase		,	training=lowerCAmelCase							)
		self.parent.assertEqual(result.last_hidden_state.shape		,	(self.batch_size, self.seq_length, self.hidden_size)							)




	def       __A					(		self	:						List[Any]		,	lowerCAmelCase	:						int		,	lowerCAmelCase	:						List[Any]		,	lowerCAmelCase	:						Union[str, Any]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			TFViTMAEForPreTraining(lowerCAmelCase							)
		UpperCAmelCase_       				=			model(lowerCAmelCase		,	training=lowerCAmelCase							)
		# expected sequence length = num_patches
		UpperCAmelCase_       				=			(self.image_size // self.patch_size) ** 2
		UpperCAmelCase_       				=			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_       				=			1
		UpperCAmelCase_       				=			TFViTMAEForPreTraining(lowerCAmelCase							)

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




	def       __A					(		self	:						Any							):


		'''simple docstring'''







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


@require_tf
class 						__UpperCamelCase    (					lowercase     ,     lowercase     ,     unittest.TestCase						):
	SCREAMING_SNAKE_CASE__    				=     (TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
	SCREAMING_SNAKE_CASE__    				=     {'feature-extraction': TFViTMAEModel} if is_tf_available() else {}

	SCREAMING_SNAKE_CASE__    				=     False
	SCREAMING_SNAKE_CASE__    				=     False
	SCREAMING_SNAKE_CASE__    				=     False
	SCREAMING_SNAKE_CASE__    				=     False




	def       __A					(		self	:						Optional[Any]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			TFViTMAEModelTester(self							)
		UpperCAmelCase_       				=			ConfigTester(self		,	config_class=lowerCAmelCase		,	has_text_modality=lowerCAmelCase		,	hidden_size=37							)




	def       __A					(		self	:						List[Any]							):


		'''simple docstring'''







		self.config_tester.run_common_tests()




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


		'''simple docstring'''







		pass




	def       __A					(		self	:						Optional[Any]							):


		'''simple docstring'''







		UpperCAmelCase_				,   UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs_for_common()

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




	def       __A					(		self	:						Optional[Any]							):


		'''simple docstring'''







		UpperCAmelCase_				,   UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs_for_common()

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

			UpperCAmelCase_       				=			["pixel_values"]
			self.assertListEqual(arg_names[:1]		,	lowerCAmelCase							)




	def       __A					(		self	:						Optional[int]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*lowerCAmelCase							)




	def       __A					(		self	:						Tuple							):


		'''simple docstring'''







		UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_pretraining(*lowerCAmelCase							)




	def       __A					(		self	:						str							):


		'''simple docstring'''







		np.random.seed(2							)

		UpperCAmelCase_				,   UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs_for_common()

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

		for model_class in self.all_model_classes:
			UpperCAmelCase_       				=			model_class(lowerCAmelCase							)
			UpperCAmelCase_       				=			self._prepare_for_class(lowerCAmelCase		,	lowerCAmelCase							)

			UpperCAmelCase_       				=			model(lowerCAmelCase		,	noise=lowerCAmelCase							)

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

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




	def       __A					(		self	:						int							):


		'''simple docstring'''







		np.random.seed(2							)

		UpperCAmelCase_				,   UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs_for_common()

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

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

			return inputs_np_dict

		for model_class in self.all_model_classes:
			UpperCAmelCase_       				=			model_class(lowerCAmelCase							)

			UpperCAmelCase_       				=			self._prepare_for_class(lowerCAmelCase		,	lowerCAmelCase							)
			UpperCAmelCase_       				=			prepare_numpy_arrays(lowerCAmelCase							)

			UpperCAmelCase_       				=			model(lowerCAmelCase		,	noise=lowerCAmelCase							)
			UpperCAmelCase_       				=			model(**lowerCAmelCase		,	noise=lowerCAmelCase							)
			self.assert_outputs_same(lowerCAmelCase		,	lowerCAmelCase							)




	def       __A					(		self	:						Tuple		,	lowerCAmelCase	:						List[str]		,	lowerCAmelCase	:						Dict		,	lowerCAmelCase	:						Tuple							):


		'''simple docstring'''







		np.random.seed(2							)

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

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

		super().check_pt_tf_models(lowerCAmelCase		,	lowerCAmelCase		,	lowerCAmelCase							)




	def       __A					(		self	:						Tuple							):


		'''simple docstring'''







		np.random.seed(2							)

		UpperCAmelCase_				,   UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs_for_common()

		UpperCAmelCase_       				=			{
		    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							)
		}

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

		for main_layer_class in tf_main_layer_classes:
			UpperCAmelCase_       				=			main_layer_class(lowerCAmelCase							)

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

			UpperCAmelCase_       				=			tf.keras.Model(lowerCAmelCase		,	outputs=main_layer(lowerCAmelCase							)							)
			UpperCAmelCase_       				=			model(lowerCAmelCase							)

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




	@slow
	def       __A					(		self	:						Any							):


		'''simple docstring'''







		np.random.seed(2							)

		UpperCAmelCase_				,   UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs_for_common()

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

		for model_class in self.all_model_classes:
			UpperCAmelCase_       				=			model_class(lowerCAmelCase							)
			UpperCAmelCase_       				=			self._prepare_for_class(lowerCAmelCase		,	lowerCAmelCase							)
			UpperCAmelCase_       				=			model(lowerCAmelCase		,	noise=lowerCAmelCase							)

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

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

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

				UpperCAmelCase_       				=			np.amax(np.abs(out_a - out_a							)							)
				self.assertLessEqual(lowerCAmelCase		,	1e-5							)




	def       __A					(		self	:						str							):


		'''simple docstring'''







		np.random.seed(2							)

		UpperCAmelCase_				,   UpperCAmelCase_       				=			self.model_tester.prepare_config_and_inputs_for_common()

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

		for model_class in self.all_model_classes:
			UpperCAmelCase_       				=			model_class(lowerCAmelCase							)
			UpperCAmelCase_       				=			self._prepare_for_class(lowerCAmelCase		,	lowerCAmelCase							)

			UpperCAmelCase_       				=			model(lowerCAmelCase		,	noise=lowerCAmelCase							)
			UpperCAmelCase_       				=			model.get_config()
			# make sure that returned config is jsonifiable, which is required by keras
			json.dumps(lowerCAmelCase							)
			UpperCAmelCase_       				=			model_class.from_config(model.get_config()							)
			# make sure it also accepts a normal config
			UpperCAmelCase_       				=			model_class.from_config(model.config							)
			UpperCAmelCase_       				=			new_model(lowerCAmelCase							)  # Build model
			new_model.set_weights(model.get_weights()							)
			UpperCAmelCase_       				=			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\n    to get deterministic results."							)
	def       __A					(		self	:						Any							):


		'''simple docstring'''







		pass




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


		'''simple docstring'''







		pass




	@slow
	def       __A					(		self	:						Optional[Any]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			TFViTMAEModel.from_pretrained("google/vit-base-patch16-224"							)
		self.assertIsNotNone(lowerCAmelCase							)



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




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




	@cached_property
	def       __A					(		self	:						Any							):


		'''simple docstring'''







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




	@slow
	def       __A					(		self	:						Optional[Any]							):


		'''simple docstring'''







		np.random.seed(2							)

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

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

		# forward pass
		UpperCAmelCase_       				=			model(**lowerCAmelCase		,	noise=lowerCAmelCase							)

		# verify the logits
		UpperCAmelCase_       				=			tf.convert_to_tensor([1, 196, 768]							)
		self.assertEqual(outputs.logits.shape		,	lowerCAmelCase							)

		UpperCAmelCase_       				=			tf.convert_to_tensor(
		    [[-0.0_548, -1.7_023, -0.9_325], [0.3_721, -0.5_670, -0.2_233], [0.8_235, -1.3_878, -0.3_524]]							)

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