



import inspect
import unittest
import warnings
from typing import List

from transformers import EfficientFormerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
	    MODEL_MAPPING,
	    EfficientFormerForImageClassification,
	    EfficientFormerForImageClassificationWithTeacher,
	    EfficientFormerModel,
	)
	from transformers.models.efficientformer.modeling_efficientformer import (
	    EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
	)


if is_vision_available():
	from PIL import Image

	from transformers import EfficientFormerImageProcessor





class  __lowerCAmelCase			:




				def __init__(							self						,    _snake_case						,    _snake_case = 13						,    _snake_case = 64						,    _snake_case = 2						,    _snake_case = 3						,    _snake_case = 3						,    _snake_case = True						,    _snake_case = True						,    _snake_case = 128						,    _snake_case=[16, 32, 64, 128]						,    _snake_case = 7						,    _snake_case = 4						,    _snake_case = 37						,    _snake_case = "gelu"						,    _snake_case = 0.1						,    _snake_case = 0.1						,    _snake_case = 10						,    _snake_case = 0.02						,    _snake_case = 2						,    _snake_case = 1						,    _snake_case = 128						,    _snake_case = [2, 2, 2, 2]						,    _snake_case = 2						,    _snake_case = 2						,    ):



									"""simple docstring"""





									_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      =   encoder_stride
									_lowerCAmelCase      =   num_attention_outputs
									_lowerCAmelCase      =   embed_dim
									_lowerCAmelCase      =   embed_dim + 1
									_lowerCAmelCase      =   resolution
									_lowerCAmelCase      =   depths
									_lowerCAmelCase      =   hidden_sizes
									_lowerCAmelCase      =   dim
									_lowerCAmelCase      =   mlp_expansion_ratio




				def 							snake_case       (							self		):



									"""simple docstring"""





									_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 							snake_case       (							self		):



									"""simple docstring"""





									return EfficientFormerConfig(
									    image_size=self.image_size						,    patch_size=self.patch_size						,    num_channels=self.num_channels						,    hidden_size=self.hidden_size						,    num_hidden_layers=self.num_hidden_layers						,    num_attention_heads=self.num_attention_heads						,    intermediate_size=self.intermediate_size						,    hidden_act=self.hidden_act						,    hidden_dropout_prob=self.hidden_dropout_prob						,    attention_probs_dropout_prob=self.attention_probs_dropout_prob						,    is_decoder=_snake_case						,    initializer_range=self.initializer_range						,    encoder_stride=self.encoder_stride						,    resolution=self.resolution						,    depths=self.depths						,    hidden_sizes=self.hidden_sizes						,    dim=self.dim						,    mlp_expansion_ratio=self.mlp_expansion_ratio						,    )




				def 							snake_case       (							self						,    _snake_case						,    _snake_case						,    _snake_case		):



									"""simple docstring"""





									_lowerCAmelCase      =   EfficientFormerModel(config=_snake_case		)
									model.to(_snake_case		)
									model.eval()
									_lowerCAmelCase      =   model(_snake_case		)
									self.parent.assertEqual(result.last_hidden_state.shape						,    (self.batch_size, self.seq_length, self.hidden_size)		)




				def 							snake_case       (							self						,    _snake_case						,    _snake_case						,    _snake_case		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.type_sequence_label_size
									_lowerCAmelCase      =   EfficientFormerForImageClassification(_snake_case		)
									model.to(_snake_case		)
									model.eval()
									_lowerCAmelCase      =   model(_snake_case						,    labels=_snake_case		)
									self.parent.assertEqual(result.logits.shape						,    (self.batch_size, self.type_sequence_label_size)		)

									# test greyscale images
									_lowerCAmelCase      =   1
									_lowerCAmelCase      =   EfficientFormerForImageClassification(_snake_case		)
									model.to(_snake_case		)
									model.eval()

									_lowerCAmelCase      =   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]		)
									_lowerCAmelCase      =   model(_snake_case		)
									self.parent.assertEqual(result.logits.shape						,    (self.batch_size, self.type_sequence_label_size)		)




				def 							snake_case       (							self		):



									"""simple docstring"""





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





@require_torch
class  __lowerCAmelCase			(					lowerCamelCase__	,						lowerCamelCase__	,						unittest.TestCase	):
				__lowerCamelCase			=    (
				    (
				        EfficientFormerModel,
				        EfficientFormerForImageClassificationWithTeacher,
				        EfficientFormerForImageClassification,
				    )
				    if is_torch_available()
				    else ()
				)
				__lowerCamelCase			=    (
				    {
				        '''feature-extraction''': EfficientFormerModel,
				        '''image-classification''': (
				            EfficientFormerForImageClassification,
				            EfficientFormerForImageClassificationWithTeacher,
				        ),
				    }
				    if is_torch_available()
				    else {}
				)
				__lowerCamelCase			=    False

				__lowerCamelCase			=    False
				__lowerCamelCase			=    False
				__lowerCamelCase			=    False




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   EfficientFormerModelTester(self		)
									_lowerCAmelCase      =   ConfigTester(
									    self						,    config_class=_snake_case						,    has_text_modality=_snake_case						,    hidden_size=37		)




				def 							snake_case       (							self		):



									"""simple docstring"""





									self.config_tester.run_common_tests()




				@unittest.skip(reason="""EfficientFormer does not use inputs_embeds"""		)
				def 							snake_case       (							self		):



									"""simple docstring"""





									pass




				@unittest.skip(reason="""EfficientFormer does not support input and output embeddings"""		)
				def 							snake_case       (							self		):



									"""simple docstring"""





									pass




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase     ,     _lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs_for_common()

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

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




				def 							snake_case       (							self		):



									"""simple docstring"""





									def check_hidden_states_output(_snake_case						,    _snake_case						,    _snake_case		):
														_lowerCAmelCase      =   model_class(_snake_case		)
														model.to(_snake_case		)
														model.eval()

														with torch.no_grad():
																			_lowerCAmelCase      =   model(**self._prepare_for_class(_snake_case						,    _snake_case		)		)

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

														_lowerCAmelCase      =   getattr(
														    self.model_tester						,    """expected_num_hidden_layers"""						,    self.model_tester.num_hidden_layers + 1		)
														self.assertEqual(len(_snake_case		)						,    _snake_case		)

														if hasattr(self.model_tester						,    """encoder_seq_length"""		):
																			_lowerCAmelCase      =   self.model_tester.encoder_seq_length
																			if hasattr(self.model_tester						,    """chunk_length"""		) and self.model_tester.chunk_length > 1:
																								_lowerCAmelCase      =   seq_length * self.model_tester.chunk_length
														else:
																			_lowerCAmelCase      =   self.model_tester.seq_length

														self.assertListEqual(
														    list(hidden_states[-1].shape[-2:]		)						,    [seq_length, self.model_tester.hidden_size]						,    )

														if config.is_encoder_decoder:
																			_lowerCAmelCase      =   outputs.decoder_hidden_states

																			self.assertIsInstance(_snake_case						,    (list, tuple)		)
																			self.assertEqual(len(_snake_case		)						,    _snake_case		)
																			_lowerCAmelCase      =   getattr(self.model_tester						,    """seq_length"""						,    _snake_case		)
																			_lowerCAmelCase      =   getattr(self.model_tester						,    """decoder_seq_length"""						,    _snake_case		)

																			self.assertListEqual(
																			    list(hidden_states[-1].shape[-2:]		)						,    [decoder_seq_length, self.model_tester.hidden_size]						,    )

									_lowerCAmelCase     ,     _lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
														_lowerCAmelCase      =   True
														check_hidden_states_output(_snake_case						,    _snake_case						,    _snake_case		)

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

														check_hidden_states_output(_snake_case						,    _snake_case						,    _snake_case		)




				def 							snake_case       (							self						,    _snake_case						,    _snake_case						,    _snake_case=False		):



									"""simple docstring"""





									_lowerCAmelCase      =   super()._prepare_for_class(_snake_case						,    _snake_case						,    return_labels=_snake_case		)

									if return_labels:
														if model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher":
																			del inputs_dict["labels"]

									return inputs_dict




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_snake_case		)




				@unittest.skip(reason="""EfficientFormer does not implement masked image modeling yet"""		)
				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*_snake_case		)




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*_snake_case		)




				def 							snake_case       (							self		):



									"""simple docstring"""





									if not self.model_tester.is_training:
														return

									_lowerCAmelCase     ,     _lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs_for_common()
									_lowerCAmelCase      =   True

									for model_class in self.all_model_classes:
														# EfficientFormerForImageClassificationWithTeacher supports inference-only
														if (
														    model_class in get_values(_snake_case		)
														    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
														):
																			continue
														_lowerCAmelCase      =   model_class(_snake_case		)
														model.to(_snake_case		)
														model.train()
														_lowerCAmelCase      =   self._prepare_for_class(_snake_case						,    _snake_case						,    return_labels=_snake_case		)
														_lowerCAmelCase      =   model(**_snake_case		).loss
														loss.backward()




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase     ,     _lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs_for_common()

									_lowerCAmelCase      =   [
									    {"""title""": """multi_label_classification""", """num_labels""": 2, """dtype""": torch.float},
									    {"""title""": """single_label_classification""", """num_labels""": 1, """dtype""": torch.long},
									    {"""title""": """regression""", """num_labels""": 1, """dtype""": torch.float},
									]

									for model_class in self.all_model_classes:
														if (
														    model_class
														    not in [
														        *get_values(_snake_case		),
														    ]
														    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
														):
																			continue

														for problem_type in problem_types:
																			with self.subTest(msg=F'Testing {model_class} with {problem_type["title"]}'		):
																								_lowerCAmelCase      =   problem_type["""title"""]
																								_lowerCAmelCase      =   problem_type["""num_labels"""]

																								_lowerCAmelCase      =   model_class(_snake_case		)
																								model.to(_snake_case		)
																								model.train()

																								_lowerCAmelCase      =   self._prepare_for_class(_snake_case						,    _snake_case						,    return_labels=_snake_case		)

																								if problem_type["num_labels"] > 1:
																													_lowerCAmelCase      =   inputs["""labels"""].unsqueeze(1		).repeat(1						,    problem_type["""num_labels"""]		)

																								_lowerCAmelCase      =   inputs["""labels"""].to(problem_type["""dtype"""]		)

																								# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
																								# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
																								# they have the same size." which is a symptom something in wrong for the regression problem.
																								# See https://github.com/huggingface/transformers/issues/11780
																								with warnings.catch_warnings(record=_snake_case		) as warning_list:
																													_lowerCAmelCase      =   model(**_snake_case		).loss
																								for w in warning_list:
																													if "Using a target size that is different to the input size" in str(w.message		):
																																		raise ValueError(
																																		    F'Something is going wrong in the regression problem: intercepted {w.message}'		)

																								loss.backward()




				@slow
				def 							snake_case       (							self		):



									"""simple docstring"""





									for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														_lowerCAmelCase      =   EfficientFormerModel.from_pretrained(_snake_case		)
														self.assertIsNotNone(_snake_case		)




				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase     ,     _lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs_for_common()
									_lowerCAmelCase      =   True

									_lowerCAmelCase      =   getattr(self.model_tester						,    """seq_length"""						,    _snake_case		)
									_lowerCAmelCase      =   getattr(self.model_tester						,    """encoder_seq_length"""						,    _snake_case		)
									_lowerCAmelCase      =   getattr(self.model_tester						,    """key_length"""						,    _snake_case		)
									_lowerCAmelCase      =   getattr(self.model_tester						,    """chunk_length"""						,    _snake_case		)

									if chunk_length is not None and hasattr(self.model_tester						,    """num_hashes"""		):
														_lowerCAmelCase      =   encoder_seq_length * self.model_tester.num_hashes

									for model_class in self.all_model_classes:
														_lowerCAmelCase      =   True
														_lowerCAmelCase      =   False
														_lowerCAmelCase      =   True
														_lowerCAmelCase      =   model_class(_snake_case		)
														model.to(_snake_case		)
														model.eval()
														with torch.no_grad():
																			_lowerCAmelCase      =   model(**self._prepare_for_class(_snake_case						,    _snake_case		)		)
														_lowerCAmelCase      =   outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
														self.assertEqual(len(_snake_case		)						,    self.model_tester.num_attention_outputs		)

														# check that output_attentions also work using config
														del inputs_dict["output_attentions"]
														_lowerCAmelCase      =   True
														_lowerCAmelCase      =   model_class(_snake_case		)
														model.to(_snake_case		)
														model.eval()
														with torch.no_grad():
																			_lowerCAmelCase      =   model(**self._prepare_for_class(_snake_case						,    _snake_case		)		)
														_lowerCAmelCase      =   outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
														self.assertEqual(len(_snake_case		)						,    self.model_tester.num_attention_outputs		)

														if chunk_length is not None:
																			self.assertListEqual(
																			    list(attentions[0].shape[-4:]		)						,    [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]						,    )
														else:
																			self.assertListEqual(
																			    list(attentions[0].shape[-3:]		)						,    [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]						,    )


def 		_UpperCAmelCase    (				):





					"""simple docstring"""

					_lowerCAmelCase      =   Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""      )
					return image





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




				@cached_property
				def 							snake_case       (							self		):



									"""simple docstring"""





									return (
									    EfficientFormerImageProcessor.from_pretrained("""snap-research/efficientformer-l1-300"""		)
									    if is_vision_available()
									    else None
									)




				@slow
				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   EfficientFormerForImageClassification.from_pretrained("""snap-research/efficientformer-l1-300"""		).to(
									    _snake_case		)

									_lowerCAmelCase      =   self.default_image_processor
									_lowerCAmelCase      =   prepare_img()
									_lowerCAmelCase      =   image_processor(images=_snake_case						,    return_tensors="""pt"""		).to(_snake_case		)

									# forward pass
									with torch.no_grad():
														_lowerCAmelCase      =   model(**_snake_case		)

									# verify the logits
									_lowerCAmelCase      =   (1, 1000)
									self.assertEqual(outputs.logits.shape						,    _snake_case		)

									_lowerCAmelCase      =   torch.tensor([-0.0555, 0.4825, -0.0852]		).to(_snake_case		)
									self.assertTrue(torch.allclose(outputs.logits[0][:3]						,    _snake_case						,    atol=1e-4		)		)




				@slow
				def 							snake_case       (							self		):



									"""simple docstring"""





									_lowerCAmelCase      =   EfficientFormerForImageClassificationWithTeacher.from_pretrained(
									    """snap-research/efficientformer-l1-300"""		).to(_snake_case		)

									_lowerCAmelCase      =   self.default_image_processor
									_lowerCAmelCase      =   prepare_img()
									_lowerCAmelCase      =   image_processor(images=_snake_case						,    return_tensors="""pt"""		).to(_snake_case		)

									# forward pass
									with torch.no_grad():
														_lowerCAmelCase      =   model(**_snake_case		)

									# verify the logits
									_lowerCAmelCase      =   (1, 1000)
									self.assertEqual(outputs.logits.shape						,    _snake_case		)

									_lowerCAmelCase      =   torch.tensor([-0.1312, 0.4353, -1.0499]		).to(_snake_case		)
									self.assertTrue(torch.allclose(outputs.logits[0][:3]						,    _snake_case						,    atol=1e-4		)		)








from math import exp


def 		_UpperCAmelCase    (				snake_case      ):





					"""simple docstring"""

					return 8 * x - 2 * exp(-x      )


def 		_UpperCAmelCase    (				snake_case     ,						snake_case     ,						snake_case      ):





					"""simple docstring"""

					_lowerCAmelCase      =   lower_bound
					_lowerCAmelCase      =   upper_bound
					for _ in range(0     ,						snake_case      ):
										_lowerCAmelCase     ,     _lowerCAmelCase      =   xa, xa - (f(snake_case      ) * (xa - xa)) / (f(snake_case      ) - f(snake_case      ))
					return xa


if __name__ == "__main__":
	print(f"Example: {secant_method(1, 3, 2)}")



