






import inspect
import unittest

from transformers import EfficientNetConfig
from transformers.testing_utils import is_pipeline_test, 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 EfficientNetForImageClassification, EfficientNetModel
							from transformers.models.efficientnet.modeling_efficientnet import EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor




class 						UpperCAmelCase_  :


						'''simple docstring'''




						def __init__(		self						, _SCREAMING_SNAKE_CASE						, _SCREAMING_SNAKE_CASE=13						, _SCREAMING_SNAKE_CASE=32						, _SCREAMING_SNAKE_CASE=3						, _SCREAMING_SNAKE_CASE=[3, 3, 5]						, _SCREAMING_SNAKE_CASE=[32, 16, 24]						, _SCREAMING_SNAKE_CASE=[16, 24, 40]						, _SCREAMING_SNAKE_CASE=[1, 1, 2]						, _SCREAMING_SNAKE_CASE=[1, 1, 2]						, _SCREAMING_SNAKE_CASE=[1, 6, 6]						, _SCREAMING_SNAKE_CASE=True						, _SCREAMING_SNAKE_CASE=True						, _SCREAMING_SNAKE_CASE=37						, _SCREAMING_SNAKE_CASE="gelu"						, _SCREAMING_SNAKE_CASE=10						, )       -> Union[str, Any]:
								snake_case_ :							List[Any]         =				parent
								snake_case_ :							List[str]         =				batch_size
								snake_case_ :							Any         =				image_size
								snake_case_ :							Optional[Any]         =				num_channels
								snake_case_ :							Optional[int]         =				kernel_sizes
								snake_case_ :							int         =				in_channels
								snake_case_ :							List[str]         =				out_channels
								snake_case_ :							List[str]         =				strides
								snake_case_ :							Optional[Any]         =				num_block_repeats
								snake_case_ :							List[str]         =				expand_ratios
								snake_case_ :							Any         =				is_training
								snake_case_ :							int         =				hidden_act
								snake_case_ :							Optional[Any]         =				num_labels
								snake_case_ :							Any         =				use_labels






						def 					_lowerCAmelCase				(		self )       -> Dict:
								snake_case_ :							int         =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

								snake_case_ :							Tuple         =				None
								if self.use_labels:
										snake_case_ :							Dict         =				ids_tensor([self.batch_size]						, self.num_labels )

								snake_case_ :							Tuple         =				self.get_config()
								return config, pixel_values, labels






						def 					_lowerCAmelCase				(		self )       -> str:
								return EfficientNetConfig(
								    num_channels=self.num_channels						, kernel_sizes=self.kernel_sizes						, in_channels=self.in_channels						, out_channels=self.out_channels						, strides=self.strides						, num_block_repeats=self.num_block_repeats						, expand_ratios=self.expand_ratios						, hidden_act=self.hidden_act						, num_labels=self.num_labels						, )






						def 					_lowerCAmelCase				(		self						, _SCREAMING_SNAKE_CASE						, _SCREAMING_SNAKE_CASE						, _SCREAMING_SNAKE_CASE )       -> str:
								snake_case_ :							Optional[int]         =				EfficientNetModel(config=_SCREAMING_SNAKE_CASE )
								model.to(_SCREAMING_SNAKE_CASE )
								model.eval()
								snake_case_ :							Union[str, Any]         =				model(_SCREAMING_SNAKE_CASE )
								# expected last hidden states: B, C, H // 4, W // 4
								self.parent.assertEqual(
								    result.last_hidden_state.shape						, (self.batch_size, config.hidden_dim, self.image_size // 4, self.image_size // 4)						, )






						def 					_lowerCAmelCase				(		self						, _SCREAMING_SNAKE_CASE						, _SCREAMING_SNAKE_CASE						, _SCREAMING_SNAKE_CASE )       -> Optional[Any]:
								snake_case_ :							Union[str, Any]         =				EfficientNetForImageClassification(_SCREAMING_SNAKE_CASE )
								model.to(_SCREAMING_SNAKE_CASE )
								model.eval()
								snake_case_ :							List[Any]         =				model(_SCREAMING_SNAKE_CASE						, labels=_SCREAMING_SNAKE_CASE )
								self.parent.assertEqual(result.logits.shape						, (self.batch_size, self.num_labels) )






						def 					_lowerCAmelCase				(		self )       -> Tuple:
								snake_case_ :							Union[str, Any]         =				self.prepare_config_and_inputs()
								snake_case_       ,				snake_case_       ,				snake_case_ :							Any         =				config_and_inputs
								snake_case_ :							Optional[Any]         =				{"pixel_values": pixel_values}
								return config, inputs_dict




@require_torch
class 						UpperCAmelCase_  (		SCREAMING_SNAKE_CASE__    ,     SCREAMING_SNAKE_CASE__    ,     unittest.TestCase    ):


						'''simple docstring'''




						A   :      Tuple						 =    (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
						A   :      str						 =    (
						    {'feature-extraction': EfficientNetModel, 'image-classification': EfficientNetForImageClassification}
						    if is_torch_available()
						    else {}
						)

						A   :      Any						 =    False
						A   :      Tuple						 =    False
						A   :      Optional[int]						 =    False
						A   :      Dict						 =    False
						A   :      Any						 =    False






						def 					_lowerCAmelCase				(		self )       -> Optional[Any]:
								snake_case_ :							Optional[int]         =				EfficientNetModelTester(self )
								snake_case_ :							int         =				ConfigTester(
								    self						, config_class=_SCREAMING_SNAKE_CASE						, has_text_modality=_SCREAMING_SNAKE_CASE						, hidden_size=37 )






						def 					_lowerCAmelCase				(		self )       -> Tuple:
								self.create_and_test_config_common_properties()
								self.config_tester.create_and_test_config_to_json_string()
								self.config_tester.create_and_test_config_to_json_file()
								self.config_tester.create_and_test_config_from_and_save_pretrained()
								self.config_tester.create_and_test_config_with_num_labels()
								self.config_tester.check_config_can_be_init_without_params()
								self.config_tester.check_config_arguments_init()






						def 					_lowerCAmelCase				(		self )       -> Any:
								return






						@unittest.skip(reason="EfficientNet does not use inputs_embeds" )
						def 					_lowerCAmelCase				(		self )       -> Optional[int]:
								pass






						@unittest.skip(reason="EfficientNet does not support input and output embeddings" )
						def 					_lowerCAmelCase				(		self )       -> Optional[Any]:
								pass






						@unittest.skip(reason="EfficientNet does not use feedforward chunking" )
						def 					_lowerCAmelCase				(		self )       -> Tuple:
								pass






						def 					_lowerCAmelCase				(		self )       -> str:
								snake_case_       ,				snake_case_ :							Optional[int]         =				self.model_tester.prepare_config_and_inputs_for_common()

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

										snake_case_ :							List[str]         =				["pixel_values"]
										self.assertListEqual(arg_names[:1]						, _SCREAMING_SNAKE_CASE )






						def 					_lowerCAmelCase				(		self )       -> List[Any]:
								snake_case_ :							Any         =				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE )






						def 					_lowerCAmelCase				(		self )       -> Optional[int]:
								def check_hidden_states_output(_SCREAMING_SNAKE_CASE						, _SCREAMING_SNAKE_CASE						, _SCREAMING_SNAKE_CASE ):
										snake_case_ :							Union[str, Any]         =				model_class(_SCREAMING_SNAKE_CASE )
										model.to(_SCREAMING_SNAKE_CASE )
										model.eval()

										with torch.no_grad():
												snake_case_ :							str         =				model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE						, _SCREAMING_SNAKE_CASE ) )

										snake_case_ :							int         =				outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
										snake_case_ :							Union[str, Any]         =				sum(config.num_block_repeats ) * 4
										self.assertEqual(len(_SCREAMING_SNAKE_CASE )						, _SCREAMING_SNAKE_CASE )

										# EfficientNet'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]						, )

								snake_case_       ,				snake_case_ :							str         =				self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										snake_case_ :							str         =				True
										check_hidden_states_output(_SCREAMING_SNAKE_CASE						, _SCREAMING_SNAKE_CASE						, _SCREAMING_SNAKE_CASE )

										# check that output_hidden_states also work using config
										del inputs_dict["output_hidden_states"]
										snake_case_ :							Tuple         =				True

										check_hidden_states_output(_SCREAMING_SNAKE_CASE						, _SCREAMING_SNAKE_CASE						, _SCREAMING_SNAKE_CASE )






						def 					_lowerCAmelCase				(		self )       -> Any:
								snake_case_ :							int         =				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE )






						@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests." )
						def 					_lowerCAmelCase				(		self )       -> Tuple:
								pass






						@slow
						def 					_lowerCAmelCase				(		self )       -> Union[str, Any]:
								for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										snake_case_ :							Dict         =				EfficientNetModel.from_pretrained(_SCREAMING_SNAKE_CASE )
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE )






						@is_pipeline_test
						@require_vision
						@slow
						def 					_lowerCAmelCase				(		self )       -> Tuple:
								super().test_pipeline_image_classification()




def    lowerCAmelCase__		(			):
		snake_case_ :							Any         =				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
		return image




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


						'''simple docstring'''




						@cached_property
						def 					_lowerCAmelCase				(		self )       -> Any:
								return AutoImageProcessor.from_pretrained("google/efficientnet-b7" ) if is_vision_available() else None






						@slow
						def 					_lowerCAmelCase				(		self )       -> Dict:
								snake_case_ :							List[Any]         =				EfficientNetForImageClassification.from_pretrained("google/efficientnet-b7" ).to(_SCREAMING_SNAKE_CASE )

								snake_case_ :							int         =				self.default_image_processor
								snake_case_ :							Optional[Any]         =				prepare_img()
								snake_case_ :							int         =				image_processor(images=_SCREAMING_SNAKE_CASE						, return_tensors="pt" ).to(_SCREAMING_SNAKE_CASE )

								# forward pass
								with torch.no_grad():
										snake_case_ :							Optional[Any]         =				model(**_SCREAMING_SNAKE_CASE )

								# verify the logits
								snake_case_ :							str         =				torch.Size((1, 1000) )
								self.assertEqual(outputs.logits.shape						, _SCREAMING_SNAKE_CASE )

								snake_case_ :							Dict         =				torch.tensor([0.0001, 0.0002, 0.0002] ).to(_SCREAMING_SNAKE_CASE )
								self.assertTrue(torch.allclose(outputs.logits[0, :3]						, _SCREAMING_SNAKE_CASE						, atol=1e-4 ) )








from __future__ import annotations

def    lowerCAmelCase__		(			_a				:	list[int]     ,					_a				:	int			):
		snake_case_       ,				snake_case_ :							Tuple         =				0, len(_a			) - 1
		while start_ind <= end_ind:
				if array[start_ind] == search_item:
						return start_ind
				elif array[end_ind] == search_item:
						return end_ind
				else:
						start_ind += 1
						end_ind -= 1
    # returns -1 if search_item is not found in array
		return -1


if __name__ == "__main__":
							print(double_linear_search(list(range(1_00)), 40))
