




'''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      A       :







							def __init__(    self			:    int				,     lowerCAmelCase_			:    Dict				,     lowerCAmelCase_			:    List[Any]=13				,     lowerCAmelCase_			:    Any=30				,     lowerCAmelCase_			:    int=2				,     lowerCAmelCase_			:    Union[str, Any]=3				,     lowerCAmelCase_			:    List[Any]=True				,     lowerCAmelCase_			:    Any=True				,     lowerCAmelCase_			:    Dict=32				,     lowerCAmelCase_			:    Optional[Any]=2				,     lowerCAmelCase_			:    Optional[Any]=4				,     lowerCAmelCase_			:    List[Any]=37				,     lowerCAmelCase_			:    str="gelu"				,     lowerCAmelCase_			:    Optional[Any]=0.1				,     lowerCAmelCase_			:    Optional[int]=0.1				,     lowerCAmelCase_			:    Optional[int]=10				,     lowerCAmelCase_			:    List[Any]=0.0_2				,     lowerCAmelCase_			:    List[str]=3				,     lowerCAmelCase_			:    Union[str, Any]=0.6				,     lowerCAmelCase_			:    Union[str, Any]=None				,     )     ->				List[Any]:


														"""simple docstring"""


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

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







							def   __lowerCAmelCase     (    self			:    List[str]   )     ->				Any:


														"""simple docstring"""


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

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

														_a      	=							self.get_config()

														return config, pixel_values, labels







							def   __lowerCAmelCase     (    self			:    Union[str, Any]   )     ->				Optional[int]:


														"""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   __lowerCAmelCase     (    self			:    List[Any]				,     lowerCAmelCase_			:    Optional[Any]				,     lowerCAmelCase_			:    Optional[int]				,     lowerCAmelCase_			:    str   )     ->				str:


														"""simple docstring"""


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







							def   __lowerCAmelCase     (    self			:    List[str]				,     lowerCAmelCase_			:    List[str]				,     lowerCAmelCase_			:    Any				,     lowerCAmelCase_			:    int   )     ->				Dict:


														"""simple docstring"""


														_a      	=							TFViTMAEForPreTraining(lowerCAmelCase_   )
														_a      	=							model(lowerCAmelCase_				,     training=lowerCAmelCase_   )
														# expected sequence length = num_patches
														_a      	=							(self.image_size // self.patch_size) ** 2
														_a      	=							self.patch_size**2 * self.num_channels
														self.parent.assertEqual(result.logits.shape				,     (self.batch_size, num_patches, expected_num_channels)   )

														# test greyscale images
														_a      	=							1
														_a      	=							TFViTMAEForPreTraining(lowerCAmelCase_   )

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







							def   __lowerCAmelCase     (    self			:    Tuple   )     ->				Any:


														"""simple docstring"""


														_a      	=							self.prepare_config_and_inputs()
														((_a)	,				(_a)	,				(_a))      	=							config_and_inputs
														_a      	=							{'''pixel_values''': pixel_values}
														return config, inputs_dict



@require_tf
class      A       (						_a	,_a	,unittest.TestCase       ):
							lowercase_							     =							(TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
							lowercase_							     =							{'feature-extraction': TFViTMAEModel} if is_tf_available() else {}

							lowercase_							     =							False
							lowercase_							     =							False
							lowercase_							     =							False
							lowercase_							     =							False







							def   __lowerCAmelCase     (    self			:    Dict   )     ->				Dict:


														"""simple docstring"""


														_a      	=							TFViTMAEModelTester(self   )
														_a      	=							ConfigTester(self				,     config_class=lowerCAmelCase_				,     has_text_modality=lowerCAmelCase_				,     hidden_size=37   )







							def   __lowerCAmelCase     (    self			:    Optional[Any]   )     ->				Tuple:


														"""simple docstring"""


														self.config_tester.run_common_tests()







							@unittest.skip(reason='''ViTMAE does not use inputs_embeds'''   )
							def   __lowerCAmelCase     (    self			:    List[str]   )     ->				List[Any]:


														"""simple docstring"""


														pass







							def   __lowerCAmelCase     (    self			:    int   )     ->				Dict:


														"""simple docstring"""


														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

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







							def   __lowerCAmelCase     (    self			:    Union[str, Any]   )     ->				List[str]:


														"""simple docstring"""


														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

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

																					_a      	=							['''pixel_values''']
																					self.assertListEqual(arg_names[:1]				,     lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    Optional[Any]   )     ->				List[Any]:


														"""simple docstring"""


														_a      	=							self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    List[str]   )     ->				int:


														"""simple docstring"""


														_a      	=							self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_pretraining(*lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    Union[str, Any]   )     ->				Optional[Any]:


														"""simple docstring"""


														np.random.seed(2   )

														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

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

														for model_class in self.all_model_classes:
																					_a      	=							model_class(lowerCAmelCase_   )
																					_a      	=							self._prepare_for_class(lowerCAmelCase_				,     lowerCAmelCase_   )

																					_a      	=							model(lowerCAmelCase_				,     noise=lowerCAmelCase_   )

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

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







							def   __lowerCAmelCase     (    self			:    List[Any]   )     ->				List[str]:


														"""simple docstring"""


														np.random.seed(2   )

														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

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

														def prepare_numpy_arrays(lowerCAmelCase_			:    List[str]   ):
																					_a      	=							{}
																					for k, v in inputs_dict.items():
																												if tf.is_tensor(lowerCAmelCase_   ):
																																			_a      	=							v.numpy()
																												else:
																																			_a      	=							np.array(lowerCAmelCase_   )

																					return inputs_np_dict

														for model_class in self.all_model_classes:
																					_a      	=							model_class(lowerCAmelCase_   )

																					_a      	=							self._prepare_for_class(lowerCAmelCase_				,     lowerCAmelCase_   )
																					_a      	=							prepare_numpy_arrays(lowerCAmelCase_   )

																					_a      	=							model(lowerCAmelCase_				,     noise=lowerCAmelCase_   )
																					_a      	=							model(**lowerCAmelCase_				,     noise=lowerCAmelCase_   )
																					self.assert_outputs_same(lowerCAmelCase_				,     lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    Union[str, Any]				,     lowerCAmelCase_			:    str				,     lowerCAmelCase_			:    Union[str, Any]				,     lowerCAmelCase_			:    Optional[int]   )     ->				Any:


														"""simple docstring"""


														np.random.seed(2   )

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

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

														super().check_pt_tf_models(lowerCAmelCase_				,     lowerCAmelCase_				,     lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    Dict   )     ->				Any:


														"""simple docstring"""


														np.random.seed(2   )

														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

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

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

														for main_layer_class in tf_main_layer_classes:
																					_a      	=							main_layer_class(lowerCAmelCase_   )

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

																					_a      	=							tf.keras.Model(lowerCAmelCase_				,     outputs=main_layer(lowerCAmelCase_   )   )
																					_a      	=							model(lowerCAmelCase_   )

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







							@slow
							def   __lowerCAmelCase     (    self			:    Optional[int]   )     ->				str:


														"""simple docstring"""


														np.random.seed(2   )

														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

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

														for model_class in self.all_model_classes:
																					_a      	=							model_class(lowerCAmelCase_   )
																					_a      	=							self._prepare_for_class(lowerCAmelCase_				,     lowerCAmelCase_   )
																					_a      	=							model(lowerCAmelCase_				,     noise=lowerCAmelCase_   )

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

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

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

																												_a      	=							np.amax(np.abs(out_a - out_a   )   )
																												self.assertLessEqual(lowerCAmelCase_				,     1e-5   )







							def   __lowerCAmelCase     (    self			:    List[Any]   )     ->				Tuple:


														"""simple docstring"""


														np.random.seed(2   )

														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

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

														for model_class in self.all_model_classes:
																					_a      	=							model_class(lowerCAmelCase_   )
																					_a      	=							self._prepare_for_class(lowerCAmelCase_				,     lowerCAmelCase_   )

																					_a      	=							model(lowerCAmelCase_				,     noise=lowerCAmelCase_   )
																					_a      	=							model.get_config()
																					# make sure that returned config is jsonifiable, which is required by keras
																					json.dumps(lowerCAmelCase_   )
																					_a      	=							model_class.from_config(model.get_config()   )
																					# make sure it also accepts a normal config
																					_a      	=							model_class.from_config(model.config   )
																					_a      	=							new_model(lowerCAmelCase_   )  # Build model
																					new_model.set_weights(model.get_weights()   )
																					_a      	=							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   __lowerCAmelCase     (    self			:    Tuple   )     ->				Optional[int]:


														"""simple docstring"""


														pass







							@unittest.skip(reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load'''   )
							def   __lowerCAmelCase     (    self			:    Union[str, Any]   )     ->				List[Any]:


														"""simple docstring"""


														pass







							@slow
							def   __lowerCAmelCase     (    self			:    Tuple   )     ->				str:


														"""simple docstring"""


														_a      	=							TFViTMAEModel.from_pretrained('''google/vit-base-patch16-224'''   )
														self.assertIsNotNone(lowerCAmelCase_   )



def 						snake_case_       ():





							'''simple docstring'''


							_a      	=							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
							return image

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







							@cached_property
							def   __lowerCAmelCase     (    self			:    int   )     ->				Optional[Any]:


														"""simple docstring"""


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







							@slow
							def   __lowerCAmelCase     (    self			:    Dict   )     ->				Any:


														"""simple docstring"""


														np.random.seed(2   )

														_a      	=							TFViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base'''   )

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

														# forward pass
														_a      	=							model(**lowerCAmelCase_				,     noise=lowerCAmelCase_   )

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

														_a      	=							tf.convert_to_tensor(
														    [[-0.0_5_4_8, -1.7_0_2_3, -0.9_3_2_5], [0.3_7_2_1, -0.5_6_7_0, -0.2_2_3_3], [0.8_2_3_5, -1.3_8_7_8, -0.3_5_2_4]]   )

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






from __future__ import annotations

import time

import numpy as np

lowercase_													=      [8, 5, 9, 7]
lowercase_													=      [
    [2, 0, 1, 1],
    [0, 1, 2, 1],
    [4, 0, 0, 3],
    [0, 2, 1, 0],
    [1, 0, 3, 0],
]
lowercase_													=      [
    [3, 2, 1, 4],
    [0, 2, 5, 2],
    [5, 1, 0, 5],
    [1, 5, 3, 0],
    [3, 0, 3, 3],
]






class     __a			:



	def __init__(    self				:     Tuple					,						snake_case_				:     list[int]					,						snake_case_				:     list[list[int]]					,						snake_case_				:     list[list[int]]					,						)->				None:
						__lowerCAmelCase						 =claim_vector
						__lowerCAmelCase						 =allocated_resources_table
						__lowerCAmelCase						 =maximum_claim_table



	def 		UpperCamelCase				(    self				:     Optional[int])->				list[int]:
						return [
						    sum(p_item[i] for p_item in self.__allocated_resources_table)
						    for i in range(len(self.__allocated_resources_table[0]))
						]



	def 		UpperCamelCase				(    self				:     Dict)->				list[int]:
						return np.array(self.__claim_vector) - np.array(
						    self.__processes_resource_summation())



	def 		UpperCamelCase				(    self				:     Optional[Any])->				list[list[int]]:
						return [
						    list(np.array(self.__maximum_claim_table[i]) - np.array(snake_case_))
						    for i, allocated_resource in enumerate(self.__allocated_resources_table)
						]



	def 		UpperCamelCase				(    self				:     Dict)->				dict[int, list[int]]:
						return {self.__need().index(snake_case_): i for i in self.__need()}



	def 		UpperCamelCase				(    self				:     Optional[Any]					,						**snake_case_				:     Optional[Any])->				None:
						__lowerCAmelCase						 =self.__need()
						__lowerCAmelCase						 =self.__allocated_resources_table
						__lowerCAmelCase						 =self.__available_resources()
						__lowerCAmelCase						 =self.__need_index_manager()
						for kw, val in kwargs.items():
											if kw and val is True:
																self.__pretty_data()
						print("""_""" * 50 + """\n""")
						while need_list:
											__lowerCAmelCase						 =False
											for each_need in need_list:
																__lowerCAmelCase						 =True
																for index, need in enumerate(snake_case_):
																					if need > available_resources[index]:
																										__lowerCAmelCase						 =False
																										break
																if execution:
																					__lowerCAmelCase						 =True
																					# get the original index of the process from ind_ctrl db
																					for original_need_index, need_clone in need_index_manager.items():
																										if each_need == need_clone:
																															__lowerCAmelCase						 =original_need_index
																					print(F"""Process {process_number + 1} is executing.""")
																					# remove the process run from stack
																					need_list.remove(snake_case_)
																					# update available/freed resources stack
																					__lowerCAmelCase						 =np.array(snake_case_) + np.array(
																					    alloc_resources_table[process_number])
																					print(
																					    """Updated available resource stack for processes: """
																					    + """ """.join([str(snake_case_) for x in available_resources]))
																					break
											if safe:
																print("""The process is in a safe state.\n""")
											else:
																print("""System in unsafe state. Aborting...\n""")
																break



	def 		UpperCamelCase				(    self				:     List[str])->				Optional[Any]:
						print(""" """ * 9 + """Allocated Resource Table""")
						for item in self.__allocated_resources_table:
											print(
											    F"""P{self.__allocated_resources_table.index(snake_case_) + 1}"""
											    + """ """.join(F"""{it:>8}""" for it in item)
											    + """\n""")
						print(""" """ * 9 + """System Resource Table""")
						for item in self.__maximum_claim_table:
											print(
											    F"""P{self.__maximum_claim_table.index(snake_case_) + 1}"""
											    + """ """.join(F"""{it:>8}""" for it in item)
											    + """\n""")
						print(
						    """Current Usage by Active Processes: """
						    + """ """.join(str(snake_case_) for x in self.__claim_vector))
						print(
						    """Initial Available Resources:       """
						    + """ """.join(str(snake_case_) for x in self.__available_resources()))
						time.sleep(1)


if __name__ == "__main__":
				import doctest

				doctest.testmod()




