






'''simple docstring'''





import inspect
import unittest

from transformers import ConvNextConfig
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_backbone_common import BackboneTesterMixin
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 ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
	from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor
class 				lowercase       :


				'''simple docstring'''

				def __init__(					self     :     Optional[Any]				,     __lowerCamelCase     :     Union[str, Any]				,     __lowerCamelCase     :     Optional[Any]=13				,     __lowerCamelCase     :     Optional[Any]=32				,     __lowerCamelCase     :     Dict=3				,     __lowerCamelCase     :     int=4				,     __lowerCamelCase     :     Dict=[10, 20, 30, 40]				,     __lowerCamelCase     :     int=[2, 2, 3, 2]				,     __lowerCamelCase     :     Any=True				,     __lowerCamelCase     :     List[Any]=True				,     __lowerCamelCase     :     Any=37				,     __lowerCamelCase     :     Optional[int]="gelu"				,     __lowerCamelCase     :     List[str]=10				,     __lowerCamelCase     :     Optional[int]=0.0_2				,     __lowerCamelCase     :     Dict=["stage2", "stage3", "stage4"]				,     __lowerCamelCase     :     List[str]=[2, 3, 4]				,     __lowerCamelCase     :     List[str]=None				,     )							->							Union[str, Any]:

					'''simple docstring'''




					lowerCamelCase__  =     parent
					lowerCamelCase__  =     batch_size
					lowerCamelCase__  =     image_size
					lowerCamelCase__  =     num_channels
					lowerCamelCase__  =     num_stages
					lowerCamelCase__  =     hidden_sizes
					lowerCamelCase__  =     depths
					lowerCamelCase__  =     is_training
					lowerCamelCase__  =     use_labels
					lowerCamelCase__  =     intermediate_size
					lowerCamelCase__  =     hidden_act
					lowerCamelCase__  =     num_labels
					lowerCamelCase__  =     initializer_range
					lowerCamelCase__  =     out_features
					lowerCamelCase__  =     out_indices
					lowerCamelCase__  =     scope

				def    a__				(					self     :     str     )							->							Optional[Any]:

					'''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.num_labels     )

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

				def    a__				(					self     :     Dict     )							->							Union[str, Any]:

					'''simple docstring'''




					return ConvNextConfig(
					    num_channels=self.num_channels				,     hidden_sizes=self.hidden_sizes				,     depths=self.depths				,     num_stages=self.num_stages				,     hidden_act=self.hidden_act				,     is_decoder=__a				,     initializer_range=self.initializer_range				,     out_features=self.out_features				,     out_indices=self.out_indices				,     num_labels=self.num_labels				,     )

				def    a__				(					self     :     Optional[Any]				,     __lowerCamelCase     :     List[Any]				,     __lowerCamelCase     :     Any				,     __lowerCamelCase     :     int     )							->							List[Any]:

					'''simple docstring'''




					lowerCamelCase__  =     ConvNextModel(config=__a     )
					model.to(__a     )
					model.eval()
					lowerCamelCase__  =     model(__a     )
					# 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    a__				(					self     :     int				,     __lowerCamelCase     :     Union[str, Any]				,     __lowerCamelCase     :     List[Any]				,     __lowerCamelCase     :     Tuple     )							->							Optional[int]:

					'''simple docstring'''




					lowerCamelCase__  =     ConvNextForImageClassification(__a     )
					model.to(__a     )
					model.eval()
					lowerCamelCase__  =     model(__a				,     labels=__a     )
					self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels)     )

				def    a__				(					self     :     List[Any]				,     __lowerCamelCase     :     Any				,     __lowerCamelCase     :     Optional[int]				,     __lowerCamelCase     :     Tuple     )							->							List[str]:

					'''simple docstring'''




					lowerCamelCase__  =     ConvNextBackbone(config=__a     )
					model.to(__a     )
					model.eval()
					lowerCamelCase__  =     model(__a     )

					# verify hidden states
					self.parent.assertEqual(len(result.feature_maps     )				,     len(config.out_features     )     )
					self.parent.assertListEqual(list(result.feature_maps[0].shape     )				,     [self.batch_size, self.hidden_sizes[1], 4, 4]     )

					# verify channels
					self.parent.assertEqual(len(model.channels     )				,     len(config.out_features     )     )
					self.parent.assertListEqual(model.channels				,     config.hidden_sizes[1:]     )

					# verify backbone works with out_features=None
					lowerCamelCase__  =     None
					lowerCamelCase__  =     ConvNextBackbone(config=__a     )
					model.to(__a     )
					model.eval()
					lowerCamelCase__  =     model(__a     )

					# verify feature maps
					self.parent.assertEqual(len(result.feature_maps     )				,     1     )
					self.parent.assertListEqual(list(result.feature_maps[0].shape     )				,     [self.batch_size, self.hidden_sizes[-1], 1, 1]     )

					# verify channels
					self.parent.assertEqual(len(model.channels     )				,     1     )
					self.parent.assertListEqual(model.channels				,     [config.hidden_sizes[-1]]     )




				def    a__				(					self     :     Optional[Any]     )							->							Any:

					'''simple docstring'''




					lowerCamelCase__  =     self.prepare_config_and_inputs()
					lowerCamelCase__  =     config_and_inputs
					lowerCamelCase__  =     {"""pixel_values""": pixel_values}
					return config, inputs_dict
@require_torch
class 				lowercase       (							__lowercase ,       __lowercase ,       unittest.TestCase      ):


				'''simple docstring'''

				lowerCAmelCase__      				=							(
				    (
				        ConvNextModel,
				        ConvNextForImageClassification,
				        ConvNextBackbone,
				    )
				    if is_torch_available()
				    else ()
				)
				lowerCAmelCase__      				=							(
				    {'''feature-extraction''': ConvNextModel, '''image-classification''': ConvNextForImageClassification}
				    if is_torch_available()
				    else {}
				)

				lowerCAmelCase__      				=							True
				lowerCAmelCase__      				=							False
				lowerCAmelCase__      				=							False
				lowerCAmelCase__      				=							False
				lowerCAmelCase__      				=							False

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

					'''simple docstring'''




					lowerCamelCase__  =     ConvNextModelTester(self     )
					lowerCamelCase__  =     ConfigTester(self				,     config_class=__a				,     has_text_modality=__a				,     hidden_size=37     )

				def    a__				(					self     :     Optional[int]     )							->							Dict:

					'''simple docstring'''




					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    a__				(					self     :     Optional[int]     )							->							Optional[Any]:

					'''simple docstring'''




					return

				@unittest.skip(reason="ConvNext does not use inputs_embeds"     )
				def    a__				(					self     :     int     )							->							Dict:

					'''simple docstring'''




					pass

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

					'''simple docstring'''




					pass

				@unittest.skip(reason="ConvNext does not use feedforward chunking"     )
				def    a__				(					self     :     int     )							->							List[Any]:

					'''simple docstring'''




					pass

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

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						lowerCamelCase__  =     model_class(__a     )
						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]				,     __a     )

				def    a__				(					self     :     Optional[int]     )							->							str:

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*__a     )

				def    a__				(					self     :     str     )							->							int:

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*__a     )

				def    a__				(					self     :     int     )							->							Optional[int]:

					'''simple docstring'''




					def check_hidden_states_output(__lowerCamelCase     :     Tuple				,     __lowerCamelCase     :     int				,     __lowerCamelCase     :     Tuple     ):
						lowerCamelCase__  =     model_class(__a     )
						model.to(__a     )
						model.eval()

						with torch.no_grad():
							lowerCamelCase__  =     model(**self._prepare_for_class(__a				,     __a     )     )

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

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

						# ConvNext'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 // 4, self.model_tester.image_size // 4]				,     )

					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						lowerCamelCase__  =     True
						check_hidden_states_output(__a				,     __a				,     __a     )

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

						check_hidden_states_output(__a				,     __a				,     __a     )

				def    a__				(					self     :     Dict     )							->							Optional[Any]:

					'''simple docstring'''




					lowerCamelCase__  =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*__a     )




				@slow
				def    a__				(					self     :     Optional[Any]     )							->							Tuple:

					'''simple docstring'''




					for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowerCamelCase__  =     ConvNextModel.from_pretrained(__a     )
						self.assertIsNotNone(__a     )






def    lowerCamelCase_     (    ):
	lowerCamelCase__  =     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
	return image
@require_torch
@require_vision
class 				lowercase       (							unittest.TestCase      ):


				'''simple docstring'''

				@cached_property
				def    a__				(					self     :     Dict     )							->							Union[str, Any]:

					'''simple docstring'''




					return AutoImageProcessor.from_pretrained("facebook/convnext-tiny-224"     ) if is_vision_available() else None




				@slow
				def    a__				(					self     :     List[str]     )							->							Dict:

					'''simple docstring'''




					lowerCamelCase__  =     ConvNextForImageClassification.from_pretrained("facebook/convnext-tiny-224"     ).to(__a     )

					lowerCamelCase__  =     self.default_image_processor
					lowerCamelCase__  =     prepare_img()
					lowerCamelCase__  =     image_processor(images=__a				,     return_tensors="pt"     ).to(__a     )

					# forward pass
					with torch.no_grad():
						lowerCamelCase__  =     model(**__a     )

					# verify the logits
					lowerCamelCase__  =     torch.Size((1, 1000)     )
					self.assertEqual(outputs.logits.shape				,     __a     )

					lowerCamelCase__  =     torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1]     ).to(__a     )

					self.assertTrue(torch.allclose(outputs.logits[0, :3]				,     __a				,     atol=1E-4     )     )
@require_torch
class 				lowercase       (							unittest.TestCase ,       __lowercase      ):


				'''simple docstring'''

				lowerCAmelCase__      				=							(ConvNextBackbone,) if is_torch_available() else ()
				lowerCAmelCase__      				=							ConvNextConfig

				lowerCAmelCase__      				=							False

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

					'''simple docstring'''




					lowerCamelCase__  =     ConvNextModelTester(self     )









'''simple docstring'''





from __future__ import annotations






def    lowerCamelCase_     (    lowercase__				,     lowercase__				,     lowercase__):
 lowerCamelCase__  =     list(range(len(lowercase__)))
 lowerCamelCase__  =     [v / w for v, w in zip(lowercase__				,     lowercase__)]
 index.sort(key=lambda lowercase__: ratio[i]				,     reverse=lowercase__)

 lowerCamelCase__  =     0
 lowerCamelCase__  =     [0] * len(lowercase__)
 for i in index:
  if weight[i] <= capacity:
   lowerCamelCase__  =     1
   max_value += value[i]
   capacity -= weight[i]
  else:
   lowerCamelCase__  =     capacity / weight[i]
   max_value += value[i] * capacity / weight[i]
   break

 return max_value, fractions


if __name__ == "__main__":
 import doctest

 doctest.testmod()

