"""simple docstring"""






from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

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 TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor
class        snake_case :




					"""simple docstring"""

					def __init__(       self     :			List[str]					,lowerCamelCase__     :			Union[str, Any]					,lowerCamelCase__     :			Dict=3					,lowerCamelCase__     :			List[str]=32					,lowerCamelCase__     :			Tuple=3					,lowerCamelCase__     :			List[str]=10					,lowerCamelCase__     :			str=[10, 20, 30, 40]					,lowerCamelCase__     :			List[str]=[1, 1, 2, 1]					,lowerCamelCase__     :			List[str]=True					,lowerCamelCase__     :			Dict=True					,lowerCamelCase__     :			List[str]="relu"					,lowerCamelCase__     :			Optional[Any]=3					,lowerCamelCase__     :			str=None					,):
									UpperCAmelCase__    =							parent
									UpperCAmelCase__    =							batch_size
									UpperCAmelCase__    =							image_size
									UpperCAmelCase__    =							num_channels
									UpperCAmelCase__    =							embeddings_size
									UpperCAmelCase__    =							hidden_sizes
									UpperCAmelCase__    =							depths
									UpperCAmelCase__    =							is_training
									UpperCAmelCase__    =							use_labels
									UpperCAmelCase__    =							hidden_act
									UpperCAmelCase__    =							num_labels
									UpperCAmelCase__    =							scope
									UpperCAmelCase__    =							len(lowerCamelCase__    )







					def 	__lowerCAmelCase		(       self     :			Optional[Any]    ):
									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.num_labels    )

									UpperCAmelCase__    =							self.get_config()
									return config, pixel_values, labels







					def 	__lowerCAmelCase		(       self     :			List[str]    ):
									return RegNetConfig(
									    num_channels=self.num_channels					,embeddings_size=self.embeddings_size					,hidden_sizes=self.hidden_sizes					,depths=self.depths					,hidden_act=self.hidden_act					,num_labels=self.num_labels					,)







					def 	__lowerCAmelCase		(       self     :			Optional[int]					,lowerCamelCase__     :			List[Any]					,lowerCamelCase__     :			Optional[Any]					,lowerCamelCase__     :			Optional[Any]    ):
									UpperCAmelCase__    =							TFRegNetModel(config=lowerCamelCase__    )
									UpperCAmelCase__    =							model(lowerCamelCase__					,training=lowerCamelCase__    )
									# expected last hidden states: B, C, H // 32, W // 32
									self.parent.assertEqual(
									    result.last_hidden_state.shape					,(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)					,)







					def 	__lowerCAmelCase		(       self     :			Optional[int]					,lowerCamelCase__     :			Tuple					,lowerCamelCase__     :			Dict					,lowerCamelCase__     :			int    ):
									UpperCAmelCase__    =							self.num_labels
									UpperCAmelCase__    =							TFRegNetForImageClassification(lowerCamelCase__    )
									UpperCAmelCase__    =							model(lowerCamelCase__					,labels=lowerCamelCase__					,training=lowerCamelCase__    )
									self.parent.assertEqual(result.logits.shape					,(self.batch_size, self.num_labels)    )







					def 	__lowerCAmelCase		(       self     :			str    ):
									UpperCAmelCase__    =							self.prepare_config_and_inputs()
									UpperCAmelCase__   ,			UpperCAmelCase__   ,			UpperCAmelCase__    =							config_and_inputs
									UpperCAmelCase__    =							{'pixel_values': pixel_values}
									return config, inputs_dict






@require_tf
class        snake_case (				__UpperCAmelCase   ,					__UpperCAmelCase   ,					unittest.TestCase       ):




					"""simple docstring"""

					snake_case__       					=				(TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
					snake_case__       					=				(
					    {"feature-extraction": TFRegNetModel, "image-classification": TFRegNetForImageClassification}
					    if is_tf_available()
					    else {}
					)

					snake_case__       					=				False
					snake_case__       					=				False
					snake_case__       					=				False
					snake_case__       					=				False
					snake_case__       					=				False







					def 	__lowerCAmelCase		(       self     :			str    ):
									UpperCAmelCase__    =							TFRegNetModelTester(self    )
									UpperCAmelCase__    =							ConfigTester(self					,config_class=lowerCamelCase__					,has_text_modality=lowerCamelCase__    )







					def 	__lowerCAmelCase		(       self     :			Dict    ):
									return







					@unittest.skip(reason='RegNet does not use inputs_embeds'    )
					def 	__lowerCAmelCase		(       self     :			Any    ):
									pass







					@unittest.skipIf(
					    not is_tf_available() or len(tf.config.list_physical_devices('GPU'    )    ) == 0					,reason='TF does not support backprop for grouped convolutions on CPU.'					,)
					@slow
					def 	__lowerCAmelCase		(       self     :			Optional[int]    ):
									super().test_keras_fit()







					@unittest.skip(reason='RegNet does not support input and output embeddings'    )
					def 	__lowerCAmelCase		(       self     :			Dict    ):
									pass







					def 	__lowerCAmelCase		(       self     :			Tuple    ):
									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 	__lowerCAmelCase		(       self     :			Dict    ):
									UpperCAmelCase__    =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*lowerCamelCase__    )







					def 	__lowerCAmelCase		(       self     :			Dict    ):
									def check_hidden_states_output(lowerCamelCase__     :			Optional[Any]					,lowerCamelCase__     :			Tuple					,lowerCamelCase__     :			Optional[Any]    ):
													UpperCAmelCase__    =							model_class(lowerCamelCase__    )
													UpperCAmelCase__    =							model(**self._prepare_for_class(lowerCamelCase__					,lowerCamelCase__    )					,training=lowerCamelCase__    )

													UpperCAmelCase__    =							outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													UpperCAmelCase__    =							self.model_tester.num_stages
													self.assertEqual(len(lowerCamelCase__    )					,expected_num_stages + 1    )

													# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
													self.assertListEqual(
													    list(hidden_states[0].shape[-2:]    )					,[self.model_tester.image_size // 2, self.model_tester.image_size // 2]					,)

									UpperCAmelCase__   ,			UpperCAmelCase__    =							self.model_tester.prepare_config_and_inputs_for_common()
									UpperCAmelCase__    =							['basic', 'bottleneck']
									for model_class in self.all_model_classes:
													for layer_type in layers_type:
																	UpperCAmelCase__    =							layer_type
																	UpperCAmelCase__    =							True
																	check_hidden_states_output(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__    )

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

																	check_hidden_states_output(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__    )







					def 	__lowerCAmelCase		(       self     :			Optional[int]    ):
									UpperCAmelCase__   ,			UpperCAmelCase__    =							self.model_tester.prepare_config_and_inputs_for_common()

									def check_equivalence(lowerCamelCase__     :			Optional[Any]					,lowerCamelCase__     :			Optional[int]					,lowerCamelCase__     :			Optional[Any]					,lowerCamelCase__     :			Any={}    ):
													UpperCAmelCase__    =							model(lowerCamelCase__					,return_dict=lowerCamelCase__					,**lowerCamelCase__    )
													UpperCAmelCase__    =							model(lowerCamelCase__					,return_dict=lowerCamelCase__					,**lowerCamelCase__    ).to_tuple()

													def recursive_check(lowerCamelCase__     :			str					,lowerCamelCase__     :			int    ):
																	if isinstance(lowerCamelCase__					,(List, Tuple)    ):
																					for tuple_iterable_value, dict_iterable_value in zip(lowerCamelCase__					,lowerCamelCase__    ):
																									recursive_check(lowerCamelCase__					,lowerCamelCase__    )
																	elif tuple_object is None:
																					return
																	else:
																					self.assertTrue(
																					    all(tf.equal(lowerCamelCase__					,lowerCamelCase__    )    )					,msg=(
																					        'Tuple and dict output are not equal. Difference:'
																					        f''' {tf.math.reduce_max(tf.abs(tuple_object - dict_object    )    )}'''
																					    )					,)

																	recursive_check(lowerCamelCase__					,lowerCamelCase__    )

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

													UpperCAmelCase__    =							self._prepare_for_class(lowerCamelCase__					,lowerCamelCase__    )
													UpperCAmelCase__    =							self._prepare_for_class(lowerCamelCase__					,lowerCamelCase__    )
													check_equivalence(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__    )

													UpperCAmelCase__    =							self._prepare_for_class(lowerCamelCase__					,lowerCamelCase__					,return_labels=lowerCamelCase__    )
													UpperCAmelCase__    =							self._prepare_for_class(lowerCamelCase__					,lowerCamelCase__					,return_labels=lowerCamelCase__    )
													check_equivalence(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__    )

													UpperCAmelCase__    =							self._prepare_for_class(lowerCamelCase__					,lowerCamelCase__    )
													UpperCAmelCase__    =							self._prepare_for_class(lowerCamelCase__					,lowerCamelCase__    )
													check_equivalence(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					,{'output_hidden_states': True}    )

													UpperCAmelCase__    =							self._prepare_for_class(lowerCamelCase__					,lowerCamelCase__					,return_labels=lowerCamelCase__    )
													UpperCAmelCase__    =							self._prepare_for_class(lowerCamelCase__					,lowerCamelCase__					,return_labels=lowerCamelCase__    )
													check_equivalence(lowerCamelCase__					,lowerCamelCase__					,lowerCamelCase__					,{'output_hidden_states': True}    )







					def 	__lowerCAmelCase		(       self     :			Tuple    ):
									UpperCAmelCase__    =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__    )







					@slow
					def 	__lowerCAmelCase		(       self     :			Optional[int]    ):
									for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													UpperCAmelCase__    =							TFRegNetModel.from_pretrained(lowerCamelCase__    )
													self.assertIsNotNone(lowerCamelCase__    )






def 						a_		(      ):
				UpperCAmelCase__    =							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
				return image







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




					"""simple docstring"""

					@cached_property
					def 	__lowerCAmelCase		(       self     :			Dict    ):
									return (
									    AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )
									    if is_vision_available()
									    else None
									)







					@slow
					def 	__lowerCAmelCase		(       self     :			int    ):
									UpperCAmelCase__    =							TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )

									UpperCAmelCase__    =							self.default_image_processor
									UpperCAmelCase__    =							prepare_img()
									UpperCAmelCase__    =							image_processor(images=lowerCamelCase__					,return_tensors='tf'    )

									# forward pass
									UpperCAmelCase__    =							model(**lowerCamelCase__					,training=lowerCamelCase__    )

									# verify the logits
									UpperCAmelCase__    =							tf.TensorShape((1, 1_000)    )
									self.assertEqual(outputs.logits.shape					,lowerCamelCase__    )

									UpperCAmelCase__    =							tf.constant([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]    )

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




"""simple docstring"""






def 						a_		(      lowerCamelCase      ,    lowerCamelCase ):
				return x if y == 0 else greatest_common_divisor(lowerCamelCase      ,    x % y )



def 						a_		(      lowerCamelCase      ,    lowerCamelCase ):
				return (x * y) // greatest_common_divisor(lowerCamelCase      ,    lowerCamelCase )



def 						a_		(      lowerCamelCase = 2_0 ):
				UpperCAmelCase__    =							1
				for i in range(1      ,    n + 1 ):
								UpperCAmelCase__    =							lcm(lowerCamelCase      ,    lowerCamelCase )
				return g


if __name__ == "__main__":
						print(F"""{solution() = }""")



