
'''simple docstring'''

import collections
import inspect
import unittest

from transformers import SwinConfig
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, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch
     from torch import nn

     from transformers import SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
     from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor


class 					a_					:




       def __init__(       self				,				snake_case_				,				snake_case_=1_3				,				snake_case_=3_2				,				snake_case_=2				,				snake_case_=3				,				snake_case_=1_6				,				snake_case_=[1, 2, 1]				,				snake_case_=[2, 2, 4]				,				snake_case_=2				,				snake_case_=2.0				,				snake_case_=True				,				snake_case_=0.0				,				snake_case_=0.0				,				snake_case_=0.1				,				snake_case_="gelu"				,				snake_case_=False				,				snake_case_=True				,				snake_case_=0.02				,				snake_case_=1E-5				,				snake_case_=True				,				snake_case_=None				,				snake_case_=True				,				snake_case_=1_0				,				snake_case_=8				,				snake_case_=["stage1", "stage2"]				,				snake_case_=[1, 2]				,				):
         _lowerCAmelCase    :					Optional[int]							=   parent
         _lowerCAmelCase    :					Tuple							=   batch_size
         _lowerCAmelCase    :					int							=   image_size
         _lowerCAmelCase    :					Union[str, Any]							=   patch_size
         _lowerCAmelCase    :					List[Any]							=   num_channels
         _lowerCAmelCase    :					Dict							=   embed_dim
         _lowerCAmelCase    :					str							=   depths
         _lowerCAmelCase    :					int							=   num_heads
         _lowerCAmelCase    :					str							=   window_size
         _lowerCAmelCase    :					Any							=   mlp_ratio
         _lowerCAmelCase    :					Optional[int]							=   qkv_bias
         _lowerCAmelCase    :					Optional[Any]							=   hidden_dropout_prob
         _lowerCAmelCase    :					List[Any]							=   attention_probs_dropout_prob
         _lowerCAmelCase    :					List[Any]							=   drop_path_rate
         _lowerCAmelCase    :					Any							=   hidden_act
         _lowerCAmelCase    :					Any							=   use_absolute_embeddings
         _lowerCAmelCase    :					int							=   patch_norm
         _lowerCAmelCase    :					int							=   layer_norm_eps
         _lowerCAmelCase    :					Optional[Any]							=   initializer_range
         _lowerCAmelCase    :					List[str]							=   is_training
         _lowerCAmelCase    :					Any							=   scope
         _lowerCAmelCase    :					List[str]							=   use_labels
         _lowerCAmelCase    :					Optional[int]							=   type_sequence_label_size
         _lowerCAmelCase    :					Tuple							=   encoder_stride
         _lowerCAmelCase    :					List[Any]							=   out_features
         _lowerCAmelCase    :					Tuple							=   out_indices




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					List[Any]							=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

         _lowerCAmelCase    :					Optional[int]							=   None
         if self.use_labels:
           _lowerCAmelCase    :					List[str]							=   ids_tensor([self.batch_size]				,				self.type_sequence_label_size					)

         _lowerCAmelCase    :					Tuple							=   self.get_config()

         return config, pixel_values, labels




       def 							__UpperCamelCase    (       self					):
         return SwinConfig(
             image_size=self.image_size				,				patch_size=self.patch_size				,				num_channels=self.num_channels				,				embed_dim=self.embed_dim				,				depths=self.depths				,				num_heads=self.num_heads				,				window_size=self.window_size				,				mlp_ratio=self.mlp_ratio				,				qkv_bias=self.qkv_bias				,				hidden_dropout_prob=self.hidden_dropout_prob				,				attention_probs_dropout_prob=self.attention_probs_dropout_prob				,				drop_path_rate=self.drop_path_rate				,				hidden_act=self.hidden_act				,				use_absolute_embeddings=self.use_absolute_embeddings				,				path_norm=self.patch_norm				,				layer_norm_eps=self.layer_norm_eps				,				initializer_range=self.initializer_range				,				encoder_stride=self.encoder_stride				,				out_features=self.out_features				,				out_indices=self.out_indices				,				)




       def 							__UpperCamelCase    (       self				,				snake_case_				,				snake_case_				,				snake_case_					):
         _lowerCAmelCase    :					Union[str, Any]							=   SwinModel(config=snake_case_					)
         model.to(snake_case_					)
         model.eval()
         _lowerCAmelCase    :					Union[str, Any]							=   model(snake_case_					)

         _lowerCAmelCase    :					str							=   ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
         _lowerCAmelCase    :					int							=   int(config.embed_dim * 2 ** (len(config.depths					) - 1)					)

         self.parent.assertEqual(result.last_hidden_state.shape				,				(self.batch_size, expected_seq_len, expected_dim)					)




       def 							__UpperCamelCase    (       self				,				snake_case_				,				snake_case_				,				snake_case_					):
         _lowerCAmelCase    :					str							=   SwinBackbone(config=snake_case_					)
         model.to(snake_case_					)
         model.eval()
         _lowerCAmelCase    :					Optional[Any]							=   model(snake_case_					)

         # 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, model.channels[0], 1_6, 1_6]					)

         # verify channels
         self.parent.assertEqual(len(model.channels					)				,				len(config.out_features					)					)

         # verify backbone works with out_features=None
         _lowerCAmelCase    :					Union[str, Any]							=   None
         _lowerCAmelCase    :					List[str]							=   SwinBackbone(config=snake_case_					)
         model.to(snake_case_					)
         model.eval()
         _lowerCAmelCase    :					str							=   model(snake_case_					)

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

         # verify channels
         self.parent.assertEqual(len(model.channels					)				,				1					)




       def 							__UpperCamelCase    (       self				,				snake_case_				,				snake_case_				,				snake_case_					):
         _lowerCAmelCase    :					Dict							=   SwinForMaskedImageModeling(config=snake_case_					)
         model.to(snake_case_					)
         model.eval()
         _lowerCAmelCase    :					Optional[int]							=   model(snake_case_					)
         self.parent.assertEqual(
             result.logits.shape				,				(self.batch_size, self.num_channels, self.image_size, self.image_size)					)

         # test greyscale images
         _lowerCAmelCase    :					Union[str, Any]							=   1
         _lowerCAmelCase    :					Any							=   SwinForMaskedImageModeling(snake_case_					)
         model.to(snake_case_					)
         model.eval()

         _lowerCAmelCase    :					Union[str, Any]							=   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
         _lowerCAmelCase    :					Dict							=   model(snake_case_					)
         self.parent.assertEqual(result.logits.shape				,				(self.batch_size, 1, self.image_size, self.image_size)					)




       def 							__UpperCamelCase    (       self				,				snake_case_				,				snake_case_				,				snake_case_					):
         _lowerCAmelCase    :					Any							=   self.type_sequence_label_size
         _lowerCAmelCase    :					List[Any]							=   SwinForImageClassification(snake_case_					)
         model.to(snake_case_					)
         model.eval()
         _lowerCAmelCase    :					List[Any]							=   model(snake_case_				,				labels=snake_case_					)
         self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.type_sequence_label_size)					)

         # test greyscale images
         _lowerCAmelCase    :					Any							=   1
         _lowerCAmelCase    :					Any							=   SwinForImageClassification(snake_case_					)
         model.to(snake_case_					)
         model.eval()

         _lowerCAmelCase    :					Optional[Any]							=   floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
         _lowerCAmelCase    :					int							=   model(snake_case_					)
         self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.type_sequence_label_size)					)







       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Any							=   self.prepare_config_and_inputs()
         (
             (
             _lowerCAmelCase
         )			,   (
             _lowerCAmelCase
         )			,   (
             _lowerCAmelCase
         )			,   
         )    :					Optional[Any]							=   config_and_inputs
         _lowerCAmelCase    :					Optional[int]							=   {"""pixel_values""": pixel_values}
         return config, inputs_dict



@require_torch
class 					a_					(_a							,     _a							,     unittest.TestCase      ):
       __lowerCAmelCase      :			List[str]      = (
           (
               SwinModel,
               SwinBackbone,
               SwinForImageClassification,
               SwinForMaskedImageModeling,
           )
           if is_torch_available()
           else ()
       )
       __lowerCAmelCase      :			Any      = (
           {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
           if is_torch_available()
           else {}
       )
       __lowerCAmelCase      :			List[Any]      = True

       __lowerCAmelCase      :			List[Any]      = False
       __lowerCAmelCase      :			List[str]      = False
       __lowerCAmelCase      :			Dict      = False




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Optional[Any]							=   SwinModelTester(self					)
         _lowerCAmelCase    :					Dict							=   ConfigTester(self				,				config_class=snake_case_				,				embed_dim=3_7					)




       def 							__UpperCamelCase    (       self					):
         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 							__UpperCamelCase    (       self					):
         return




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					List[str]							=   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*snake_case_					)




       @unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""					)
       def 							__UpperCamelCase    (       self					):
         pass




       def 							__UpperCamelCase    (       self					):
         super().test_training_gradient_checkpointing()




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Optional[Any]							=   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*snake_case_					)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					int							=   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_image_modeling(*snake_case_					)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					str							=   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*snake_case_					)




       @unittest.skip(reason="""Swin does not use inputs_embeds"""					)
       def 							__UpperCamelCase    (       self					):
         pass




       @unittest.skip(reason="""Swin Transformer does not use feedforward chunking"""					)
       def 							__UpperCamelCase    (       self					):
         pass




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase			,   _lowerCAmelCase    :					Any							=   self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
           _lowerCAmelCase    :					Optional[Any]							=   model_class(snake_case_					)
           self.assertIsInstance(model.get_input_embeddings()				,				(nn.Module)					)
           _lowerCAmelCase    :					List[Any]							=   model.get_output_embeddings()
           self.assertTrue(x is None or isinstance(snake_case_				,				nn.Linear					)					)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase			,   _lowerCAmelCase    :					int							=   self.model_tester.prepare_config_and_inputs_for_common()

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

           _lowerCAmelCase    :					Union[str, Any]							=   ["""pixel_values"""]
           self.assertListEqual(arg_names[:1]				,				snake_case_					)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase			,   _lowerCAmelCase    :					str							=   self.model_tester.prepare_config_and_inputs_for_common()
         _lowerCAmelCase    :					List[Any]							=   True

         for model_class in self.all_model_classes:
           _lowerCAmelCase    :					Optional[int]							=   True
           _lowerCAmelCase    :					str							=   False
           _lowerCAmelCase    :					int							=   True
           _lowerCAmelCase    :					Dict							=   model_class(snake_case_					)
           model.to(snake_case_					)
           model.eval()
           with torch.no_grad():
             _lowerCAmelCase    :					str							=   model(**self._prepare_for_class(snake_case_				,				snake_case_					)					)
           _lowerCAmelCase    :					Optional[int]							=   outputs.attentions
           _lowerCAmelCase    :					Dict							=   len(self.model_tester.depths					)
           self.assertEqual(len(snake_case_					)				,				snake_case_					)

           # check that output_attentions also work using config
           del inputs_dict["output_attentions"]
           _lowerCAmelCase    :					List[Any]							=   True
           _lowerCAmelCase    :					List[Any]							=   config.window_size**2
           _lowerCAmelCase    :					List[Any]							=   model_class(snake_case_					)
           model.to(snake_case_					)
           model.eval()
           with torch.no_grad():
             _lowerCAmelCase    :					Union[str, Any]							=   model(**self._prepare_for_class(snake_case_				,				snake_case_					)					)
           _lowerCAmelCase    :					int							=   outputs.attentions
           self.assertEqual(len(snake_case_					)				,				snake_case_					)

           self.assertListEqual(
               list(attentions[0].shape[-3:]					)				,				[self.model_tester.num_heads[0], window_size_squared, window_size_squared]				,				)
           _lowerCAmelCase    :					List[Any]							=   len(snake_case_					)

           # Check attention is always last and order is fine
           _lowerCAmelCase    :					Optional[Any]							=   True
           _lowerCAmelCase    :					Optional[Any]							=   True
           _lowerCAmelCase    :					Tuple							=   model_class(snake_case_					)
           model.to(snake_case_					)
           model.eval()
           with torch.no_grad():
             _lowerCAmelCase    :					List[Any]							=   model(**self._prepare_for_class(snake_case_				,				snake_case_					)					)

           # also another +1 for reshaped_hidden_states
           _lowerCAmelCase    :					Tuple							=   1 if model_class.__name__ == """SwinBackbone""" else 2
           self.assertEqual(out_len + added_hidden_states				,				len(snake_case_					)					)

           _lowerCAmelCase    :					Optional[Any]							=   outputs.attentions

           self.assertEqual(len(snake_case_					)				,				snake_case_					)

           self.assertListEqual(
               list(self_attentions[0].shape[-3:]					)				,				[self.model_tester.num_heads[0], window_size_squared, window_size_squared]				,				)




       def 							__UpperCamelCase    (       self				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_					):
         _lowerCAmelCase    :					List[Any]							=   model_class(snake_case_					)
         model.to(snake_case_					)
         model.eval()

         with torch.no_grad():
           _lowerCAmelCase    :					List[Any]							=   model(**self._prepare_for_class(snake_case_				,				snake_case_					)					)

         _lowerCAmelCase    :					List[str]							=   outputs.hidden_states

         _lowerCAmelCase    :					List[Any]							=   getattr(
             self.model_tester				,				"""expected_num_hidden_layers"""				,				len(self.model_tester.depths					) + 1					)
         self.assertEqual(len(snake_case_					)				,				snake_case_					)

         # Swin has a different seq_length
         _lowerCAmelCase    :					Optional[Any]							=   (
             config.patch_size
             if isinstance(config.patch_size				,				collections.abc.Iterable					)
             else (config.patch_size, config.patch_size)
         )

         _lowerCAmelCase    :					Any							=   (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

         self.assertListEqual(
             list(hidden_states[0].shape[-2:]					)				,				[num_patches, self.model_tester.embed_dim]				,				)

         if not model_class.__name__ == "SwinBackbone":
           _lowerCAmelCase    :					List[Any]							=   outputs.reshaped_hidden_states
           self.assertEqual(len(snake_case_					)				,				snake_case_					)

           _lowerCAmelCase			,   _lowerCAmelCase			,   _lowerCAmelCase			,   _lowerCAmelCase    :					Optional[int]							=   reshaped_hidden_states[0].shape
           _lowerCAmelCase    :					Any							=   (
               reshaped_hidden_states[0].view(snake_case_				,				snake_case_				,				height * width					).permute(0				,				2				,				1					)
           )
           self.assertListEqual(
               list(reshaped_hidden_states.shape[-2:]					)				,				[num_patches, self.model_tester.embed_dim]				,				)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase			,   _lowerCAmelCase    :					Optional[int]							=   self.model_tester.prepare_config_and_inputs_for_common()

         _lowerCAmelCase    :					Optional[Any]							=   (
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size				,				collections.abc.Iterable					)
             else (self.model_tester.image_size, self.model_tester.image_size)
         )

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

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

           self.check_hidden_states_output(snake_case_				,				snake_case_				,				snake_case_				,				snake_case_					)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase			,   _lowerCAmelCase    :					Optional[Any]							=   self.model_tester.prepare_config_and_inputs_for_common()
         _lowerCAmelCase    :					Optional[Any]							=   3

         _lowerCAmelCase    :					int							=   (
             self.model_tester.image_size
             if isinstance(self.model_tester.image_size				,				collections.abc.Iterable					)
             else (self.model_tester.image_size, self.model_tester.image_size)
         )
         _lowerCAmelCase    :					List[Any]							=   (
             config.patch_size
             if isinstance(config.patch_size				,				collections.abc.Iterable					)
             else (config.patch_size, config.patch_size)
         )

         _lowerCAmelCase    :					str							=   image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
         _lowerCAmelCase    :					str							=   image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

         for model_class in self.all_model_classes:
           _lowerCAmelCase    :					Tuple							=   True
           self.check_hidden_states_output(snake_case_				,				snake_case_				,				snake_case_				,				(padded_height, padded_width)					)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           _lowerCAmelCase    :					Optional[Any]							=   True
           self.check_hidden_states_output(snake_case_				,				snake_case_				,				snake_case_				,				(padded_height, padded_width)					)




       @slow
       def 							__UpperCamelCase    (       self					):
         for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _lowerCAmelCase    :					Union[str, Any]							=   SwinModel.from_pretrained(snake_case_					)
           self.assertIsNotNone(snake_case_					)







       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase			,   _lowerCAmelCase    :					Any							=   self.model_tester.prepare_config_and_inputs_for_common()

         _lowerCAmelCase    :					Optional[Any]							=   _config_zero_init(snake_case_					)
         for model_class in self.all_model_classes:
           _lowerCAmelCase    :					Any							=   model_class(config=snake_case_					)
           for name, param in model.named_parameters():
             if "embeddings" not in name and param.requires_grad:
               self.assertIn(
                   ((param.data.mean() * 1E9).round() / 1E9).item()				,				[0.0, 1.0]				,				msg=f'Parameter {name} of model {model_class} seems not properly initialized'				,				)



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




       @cached_property
       def 							__UpperCamelCase    (       self					):
         return (
             AutoImageProcessor.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""					)
             if is_vision_available()
             else None
         )







       @slow
       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					int							=   SwinForImageClassification.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""					).to(snake_case_					)
         _lowerCAmelCase    :					int							=   self.default_image_processor

         _lowerCAmelCase    :					Optional[int]							=   Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
         _lowerCAmelCase    :					List[Any]							=   image_processor(images=snake_case_				,				return_tensors="""pt"""					).to(snake_case_					)

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

         # verify the logits
         _lowerCAmelCase    :					Any							=   torch.Size((1, 1_0_0_0)					)
         self.assertEqual(outputs.logits.shape				,				snake_case_					)
         _lowerCAmelCase    :					Optional[Any]							=   torch.tensor([-0.0948, -0.6454, -0.0921]					).to(snake_case_					)
         self.assertTrue(torch.allclose(outputs.logits[0, :3]				,				snake_case_				,				atol=1E-4					)					)



@require_torch
class 					a_					(unittest.TestCase							,     _a      ):
       __lowerCAmelCase      :			str      = (SwinBackbone,) if is_torch_available() else ()
       __lowerCAmelCase      :			Optional[Any]      = SwinConfig




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Tuple							=   SwinModelTester(self					)




'''simple docstring'''

import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
     import torch

if is_vision_available():
     from PIL import Image

     from transformers import ConvNextImageProcessor


class 					a_					(unittest.TestCase      ):




       def __init__(       self				,				snake_case_				,				snake_case_=7				,				snake_case_=3				,				snake_case_=1_8				,				snake_case_=3_0				,				snake_case_=4_0_0				,				snake_case_=True				,				snake_case_=None				,				snake_case_=0.875				,				snake_case_=True				,				snake_case_=[0.5, 0.5, 0.5]				,				snake_case_=[0.5, 0.5, 0.5]				,				):
         _lowerCAmelCase    :					List[str]							=   size if size is not None else {"""shortest_edge""": 2_0}
         _lowerCAmelCase    :					Tuple							=   parent
         _lowerCAmelCase    :					List[str]							=   batch_size
         _lowerCAmelCase    :					List[str]							=   num_channels
         _lowerCAmelCase    :					Tuple							=   image_size
         _lowerCAmelCase    :					Union[str, Any]							=   min_resolution
         _lowerCAmelCase    :					Tuple							=   max_resolution
         _lowerCAmelCase    :					List[Any]							=   do_resize
         _lowerCAmelCase    :					Dict							=   size
         _lowerCAmelCase    :					str							=   crop_pct
         _lowerCAmelCase    :					List[str]							=   do_normalize
         _lowerCAmelCase    :					Any							=   image_mean
         _lowerCAmelCase    :					Any							=   image_std







       def 							__UpperCamelCase    (       self					):
         return {
             "image_mean": self.image_mean,
             "image_std": self.image_std,
             "do_normalize": self.do_normalize,
             "do_resize": self.do_resize,
             "size": self.size,
             "crop_pct": self.crop_pct,
         }



@require_torch
@require_vision
class 					a_					(_a							,     unittest.TestCase      ):
       __lowerCAmelCase      :			Dict      = ConvNextImageProcessor if is_vision_available() else None




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					int							=   ConvNextImageProcessingTester(self					)




       @property
       def 							__UpperCamelCase    (       self					):
         return self.image_processor_tester.prepare_image_processor_dict()




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					List[Any]							=   self.image_processing_class(**self.image_processor_dict					)
         self.assertTrue(hasattr(snake_case_				,				"""do_resize"""					)					)
         self.assertTrue(hasattr(snake_case_				,				"""size"""					)					)
         self.assertTrue(hasattr(snake_case_				,				"""crop_pct"""					)					)
         self.assertTrue(hasattr(snake_case_				,				"""do_normalize"""					)					)
         self.assertTrue(hasattr(snake_case_				,				"""image_mean"""					)					)
         self.assertTrue(hasattr(snake_case_				,				"""image_std"""					)					)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Any							=   self.image_processing_class.from_dict(self.image_processor_dict					)
         self.assertEqual(image_processor.size				,				{"""shortest_edge""": 2_0}					)

         _lowerCAmelCase    :					List[Any]							=   self.image_processing_class.from_dict(self.image_processor_dict				,				size=4_2					)
         self.assertEqual(image_processor.size				,				{"""shortest_edge""": 4_2}					)




       def 							__UpperCamelCase    (       self					):
         pass




       def 							__UpperCamelCase    (       self					):
         # Initialize image_processing
         _lowerCAmelCase    :					str							=   self.image_processing_class(**self.image_processor_dict					)
         # create random PIL images
         _lowerCAmelCase    :					str							=   prepare_image_inputs(self.image_processor_tester				,				equal_resolution=snake_case_					)
         for image in image_inputs:
           self.assertIsInstance(snake_case_				,				Image.Image					)

         # Test not batched input
         _lowerCAmelCase    :					Optional[int]							=   image_processing(image_inputs[0]				,				return_tensors="""pt"""					).pixel_values
         self.assertEqual(
             encoded_images.shape				,				(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.size["""shortest_edge"""],
                 self.image_processor_tester.size["""shortest_edge"""],
             )				,				)

         # Test batched
         _lowerCAmelCase    :					Optional[Any]							=   image_processing(snake_case_				,				return_tensors="""pt"""					).pixel_values
         self.assertEqual(
             encoded_images.shape				,				(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.size["""shortest_edge"""],
                 self.image_processor_tester.size["""shortest_edge"""],
             )				,				)




       def 							__UpperCamelCase    (       self					):
         # Initialize image_processing
         _lowerCAmelCase    :					int							=   self.image_processing_class(**self.image_processor_dict					)
         # create random numpy tensors
         _lowerCAmelCase    :					Any							=   prepare_image_inputs(self.image_processor_tester				,				equal_resolution=snake_case_				,				numpify=snake_case_					)
         for image in image_inputs:
           self.assertIsInstance(snake_case_				,				np.ndarray					)

         # Test not batched input
         _lowerCAmelCase    :					Optional[Any]							=   image_processing(image_inputs[0]				,				return_tensors="""pt"""					).pixel_values
         self.assertEqual(
             encoded_images.shape				,				(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.size["""shortest_edge"""],
                 self.image_processor_tester.size["""shortest_edge"""],
             )				,				)

         # Test batched
         _lowerCAmelCase    :					List[str]							=   image_processing(snake_case_				,				return_tensors="""pt"""					).pixel_values
         self.assertEqual(
             encoded_images.shape				,				(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.size["""shortest_edge"""],
                 self.image_processor_tester.size["""shortest_edge"""],
             )				,				)







       def 							__UpperCamelCase    (       self					):
         # Initialize image_processing
         _lowerCAmelCase    :					Tuple							=   self.image_processing_class(**self.image_processor_dict					)
         # create random PyTorch tensors
         _lowerCAmelCase    :					List[str]							=   prepare_image_inputs(self.image_processor_tester				,				equal_resolution=snake_case_				,				torchify=snake_case_					)
         for image in image_inputs:
           self.assertIsInstance(snake_case_				,				torch.Tensor					)

         # Test not batched input
         _lowerCAmelCase    :					List[str]							=   image_processing(image_inputs[0]				,				return_tensors="""pt"""					).pixel_values
         self.assertEqual(
             encoded_images.shape				,				(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.size["""shortest_edge"""],
                 self.image_processor_tester.size["""shortest_edge"""],
             )				,				)

         # Test batched
         _lowerCAmelCase    :					Optional[int]							=   image_processing(snake_case_				,				return_tensors="""pt"""					).pixel_values
         self.assertEqual(
             encoded_images.shape				,				(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.size["""shortest_edge"""],
                 self.image_processor_tester.size["""shortest_edge"""],
             )				,				)


