



"""simple docstring"""
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 							lowerCamelCase    :






					'''simple docstring'''





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






					def   lowerCAmelCase_							(			self:				List[str]		)  ->      List[str]:
											snake_case_					:List[Any]		=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

											snake_case_					:Union[str, Any]		=     self.get_config()
											return config, pixel_values, labels






					def   lowerCAmelCase_							(			self:				Tuple		)  ->      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:				Any		,	snake_case:				List[Any]		,	snake_case:				List[Any]		,	snake_case:				Union[str, Any]		)  ->      str:
											snake_case_					:Any		=     EfficientNetModel(config=snake_case		)
											model.to(snake_case		)
											model.eval()
											snake_case_					:Union[str, Any]		=     model(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:				Union[str, Any]		,	snake_case:				List[Any]		,	snake_case:				Optional[int]		,	snake_case:				str		)  ->      Dict:
											snake_case_					:Union[str, Any]		=     EfficientNetForImageClassification(snake_case		)
											model.to(snake_case		)
											model.eval()
											snake_case_					:str		=     model(snake_case		,	labels=snake_case		)
											self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.num_labels)		)






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

@require_torch
class 							lowerCamelCase    (     _lowerCAmelCase       ,		_lowerCAmelCase       ,		unittest.TestCase							):






					'''simple docstring'''





					_A						:     int		=	(EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
					_A						:     List[str]		=	(
					    {"""feature-extraction""": EfficientNetModel, """image-classification""": EfficientNetForImageClassification}
					    if is_torch_available()
					    else {}
					)

					_A						:     Union[str, Any]		=	False
					_A						:     str		=	False
					_A						:     str		=	False
					_A						:     Dict		=	False
					_A						:     Dict		=	False






					def   lowerCAmelCase_							(			self:				List[str]		)  ->      int:
											snake_case_					:Any		=     EfficientNetModelTester(self		)
											snake_case_					:Union[str, Any]		=     ConfigTester(
											    self		,	config_class=snake_case		,	has_text_modality=snake_case		,	hidden_size=37		)






					def   lowerCAmelCase_							(			self:				List[Any]		)  ->      List[Any]:
											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		)  ->      List[str]:
											return






					@unittest.skip(reason="""EfficientNet does not use inputs_embeds"""		)
					def   lowerCAmelCase_							(			self:				Union[str, Any]		)  ->      Union[str, Any]:
											pass






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






					@unittest.skip(reason="""EfficientNet does not use feedforward chunking"""		)
					def   lowerCAmelCase_							(			self:				Dict		)  ->      List[str]:
											pass






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

											for model_class in self.all_model_classes:
																	snake_case_					:List[Any]		=     model_class(snake_case		)
																	snake_case_					:Union[str, Any]		=     inspect.signature(model.forward		)
																	# signature.parameters is an OrderedDict => so arg_names order is deterministic
																	snake_case_					:List[str]		=     [*signature.parameters.keys()]

																	snake_case_					:Tuple		=     ["""pixel_values"""]
																	self.assertListEqual(arg_names[:1]		,	snake_case		)






					def   lowerCAmelCase_							(			self:				Any		)  ->      List[str]:
											snake_case_					:Union[str, Any]		=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*snake_case		)






					def   lowerCAmelCase_							(			self:				int		)  ->      List[Any]:
											def check_hidden_states_output(snake_case:				Optional[Any]		,	snake_case:				Optional[Any]		,	snake_case:				Any		):
																	snake_case_					:str		=     model_class(snake_case		)
																	model.to(snake_case		)
																	model.eval()

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

																	snake_case_					:Union[str, Any]		=     outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
																	snake_case_					:Optional[int]		=     sum(config.num_block_repeats		) * 4
																	self.assertEqual(len(snake_case		)		,	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_					:Dict		=     self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	snake_case_					:Optional[Any]		=     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"]
																	snake_case_					:str		=     True

																	check_hidden_states_output(snake_case		,	snake_case		,	snake_case		)






					def   lowerCAmelCase_							(			self:				Union[str, Any]		)  ->      str:
											snake_case_					:int		=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*snake_case		)






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






					@slow
					def   lowerCAmelCase_							(			self:				Optional[int]		)  ->      Optional[Any]:
											for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	snake_case_					:Any		=     EfficientNetModel.from_pretrained(snake_case		)
																	self.assertIsNotNone(snake_case		)






					@is_pipeline_test
					@require_vision
					@slow
					def   lowerCAmelCase_							(			self:				Optional[int]		)  ->      Dict:
											super().test_pipeline_image_classification()

def   A_    (     ):







						'''simple docstring'''


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

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






					'''simple docstring'''





					@cached_property
					def   lowerCAmelCase_							(			self:				Dict		)  ->      Optional[int]:
											return AutoImageProcessor.from_pretrained("""google/efficientnet-b7"""		) if is_vision_available() else None






					@slow
					def   lowerCAmelCase_							(			self:				int		)  ->      Optional[int]:
											snake_case_					:int		=     EfficientNetForImageClassification.from_pretrained("""google/efficientnet-b7"""		).to(snake_case		)

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

											# forward pass
											with torch.no_grad():
																	snake_case_					:Tuple		=     model(**snake_case		)

											# verify the logits
											snake_case_					:Dict		=     torch.Size((1, 1_000)		)
											self.assertEqual(outputs.logits.shape		,	snake_case		)

											snake_case_					:Tuple		=     torch.tensor([0.0_0_0_1, 0.0_0_0_2, 0.0_0_0_2]		).to(snake_case		)
											self.assertTrue(torch.allclose(outputs.logits[0, :3]		,	snake_case		,	atol=1E-4		)		)





"""simple docstring"""
import os
def   A_    (     ):







						'''simple docstring'''


						snake_case_					:Optional[Any]		=     os.path.dirname(os.path.realpath(_lowercase      )      )
						snake_case_					:int		=     os.path.join(_lowercase,   """triangle.txt"""      )

						with open(_lowercase      ) as in_file:
												snake_case_					:List[Any]		=     [[int(_lowercase      ) for i in line.split()] for line in in_file]

						while len(_lowercase      ) != 1:
												snake_case_					:str		=     triangle.pop()
												snake_case_					:int		=     triangle[-1]
												for j in range(len(_lowercase      ) - 1      ):
																		curr_row[j] += max(last_row[j],   last_row[j + 1]      )
						return triangle[0][0]


if __name__ == "__main__":
						print(solution())
