



"""simple docstring"""





import math
from typing import Dict, Iterable, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    is_torch_available,
    is_torch_tensor,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_torch_available():
  import torch

if is_vision_available():
  import PIL


lowerCamelCase  			=		logging.get_logger(__name__)
def   a__      ( lowerCAmelCase__      ,     lowerCAmelCase__      ,     lowerCAmelCase__      ,     lowerCAmelCase__ ):
      def constraint_to_multiple_of(lowerCAmelCase__      ,     lowerCAmelCase__      ,     lowerCAmelCase__=0      ,     lowerCAmelCase__=None ):
            UpperCAmelCase_     					=				round(val / multiple ) * multiple

            if max_val is not None and x > max_val:
                  UpperCAmelCase_     					=				math.floor(val / multiple ) * multiple

            if x < min_val:
                  UpperCAmelCase_     					=				math.ceil(val / multiple ) * multiple

            return x

      UpperCAmelCase_     					=				(output_size, output_size) if isinstance(lowerCAmelCase__      ,     lowerCAmelCase__ ) else output_size

      UpperCAmelCase_					,       UpperCAmelCase_     					=				get_image_size(lowerCAmelCase__ )
      UpperCAmelCase_					,       UpperCAmelCase_     					=				output_size

      # determine new height and width
      UpperCAmelCase_     					=				output_height / input_height
      UpperCAmelCase_     					=				output_width / input_width

      if keep_aspect_ratio:
            # scale as little as possible
            if abs(1 - scale_width ) < abs(1 - scale_height ):
                  # fit width
                  UpperCAmelCase_     					=				scale_width
            else:
                  # fit height
                  UpperCAmelCase_     					=				scale_height

      UpperCAmelCase_     					=				constraint_to_multiple_of(scale_height * input_height      ,     multiple=lowerCAmelCase__ )
      UpperCAmelCase_     					=				constraint_to_multiple_of(scale_width * input_width      ,     multiple=lowerCAmelCase__ )

      return (new_height, new_width)


class  lowercase__  (       SCREAMING_SNAKE_CASE ):







       '''simple docstring'''


       UpperCamelCase		=	['''pixel_values''']



       def __init__(				self     :    Optional[int]						,							_UpperCAmelCase     :    bool = True						,							_UpperCAmelCase     :    Dict[str, int] = None						,							_UpperCAmelCase     :    PILImageResampling = PILImageResampling.BILINEAR						,							_UpperCAmelCase     :    bool = False						,							_UpperCAmelCase     :    int = 1						,							_UpperCAmelCase     :    bool = True						,							_UpperCAmelCase     :    Union[int, float] = 1 / 255						,							_UpperCAmelCase     :    bool = True						,							_UpperCAmelCase     :    Optional[Union[float, List[float]]] = None						,							_UpperCAmelCase     :    Optional[Union[float, List[float]]] = None						,							**_UpperCAmelCase     :    int						,							)					->		None:


             '''simple docstring'''




             super().__init__(**_UpperCAmelCase       )
             UpperCAmelCase_     					=				size if size is not None else {"height": 384, "width": 384}
             UpperCAmelCase_     					=				get_size_dict(_UpperCAmelCase       )
             UpperCAmelCase_     					=				do_resize
             UpperCAmelCase_     					=				size
             UpperCAmelCase_     					=				keep_aspect_ratio
             UpperCAmelCase_     					=				ensure_multiple_of
             UpperCAmelCase_     					=				resample
             UpperCAmelCase_     					=				do_rescale
             UpperCAmelCase_     					=				rescale_factor
             UpperCAmelCase_     					=				do_normalize
             UpperCAmelCase_     					=				image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
             UpperCAmelCase_     					=				image_std if image_std is not None else IMAGENET_STANDARD_STD



       def 	lowercase__							(				self     :    List[Any]						,							_UpperCAmelCase     :    np.ndarray						,							_UpperCAmelCase     :    Dict[str, int]						,							_UpperCAmelCase     :    bool = False						,							_UpperCAmelCase     :    int = 1						,							_UpperCAmelCase     :    PILImageResampling = PILImageResampling.BICUBIC						,							_UpperCAmelCase     :    Optional[Union[str, ChannelDimension]] = None						,							**_UpperCAmelCase     :    List[Any]						,							)					->		np.ndarray:


             '''simple docstring'''




             UpperCAmelCase_     					=				get_size_dict(_UpperCAmelCase       )
             if "height" not in size or "width" not in size:
                   raise ValueError(F"""The size dictionary must contain the keys 'height' and 'width'. Got {size.keys()}"""       )
             UpperCAmelCase_     					=				get_resize_output_image_size(
                 _UpperCAmelCase						,							output_size=(size["height"], size["width"])						,							keep_aspect_ratio=_UpperCAmelCase						,							multiple=_UpperCAmelCase						,							)
             return resize(_UpperCAmelCase						,							size=_UpperCAmelCase						,							resample=_UpperCAmelCase						,							data_format=_UpperCAmelCase						,							**_UpperCAmelCase       )



       def 	lowercase__							(				self     :    List[str]						,							_UpperCAmelCase     :    np.ndarray						,							_UpperCAmelCase     :    Union[int, float]						,							_UpperCAmelCase     :    Optional[Union[str, ChannelDimension]] = None						,							**_UpperCAmelCase     :    Union[str, Any]						,							)					->		Tuple:


             '''simple docstring'''




             return rescale(_UpperCAmelCase						,							scale=_UpperCAmelCase						,							data_format=_UpperCAmelCase						,							**_UpperCAmelCase       )



       def 	lowercase__							(				self     :    Union[str, Any]						,							_UpperCAmelCase     :    np.ndarray						,							_UpperCAmelCase     :    Union[float, List[float]]						,							_UpperCAmelCase     :    Union[float, List[float]]						,							_UpperCAmelCase     :    Optional[Union[str, ChannelDimension]] = None						,							**_UpperCAmelCase     :    Any						,							)					->		np.ndarray:


             '''simple docstring'''




             return normalize(_UpperCAmelCase						,							mean=_UpperCAmelCase						,							std=_UpperCAmelCase						,							data_format=_UpperCAmelCase						,							**_UpperCAmelCase       )



       def 	lowercase__							(				self     :    int						,							_UpperCAmelCase     :    ImageInput						,							_UpperCAmelCase     :    bool = None						,							_UpperCAmelCase     :    int = None						,							_UpperCAmelCase     :    bool = None						,							_UpperCAmelCase     :    int = None						,							_UpperCAmelCase     :    PILImageResampling = None						,							_UpperCAmelCase     :    bool = None						,							_UpperCAmelCase     :    float = None						,							_UpperCAmelCase     :    bool = None						,							_UpperCAmelCase     :    Optional[Union[float, List[float]]] = None						,							_UpperCAmelCase     :    Optional[Union[float, List[float]]] = None						,							_UpperCAmelCase     :    Optional[Union[str, TensorType]] = None						,							_UpperCAmelCase     :    ChannelDimension = ChannelDimension.FIRST						,							**_UpperCAmelCase     :    Any						,							)					->		PIL.Image.Image:


             '''simple docstring'''




             UpperCAmelCase_     					=				do_resize if do_resize is not None else self.do_resize
             UpperCAmelCase_     					=				size if size is not None else self.size
             UpperCAmelCase_     					=				get_size_dict(_UpperCAmelCase       )
             UpperCAmelCase_     					=				keep_aspect_ratio if keep_aspect_ratio is not None else self.keep_aspect_ratio
             UpperCAmelCase_     					=				ensure_multiple_of if ensure_multiple_of is not None else self.ensure_multiple_of
             UpperCAmelCase_     					=				resample if resample is not None else self.resample
             UpperCAmelCase_     					=				do_rescale if do_rescale is not None else self.do_rescale
             UpperCAmelCase_     					=				rescale_factor if rescale_factor is not None else self.rescale_factor
             UpperCAmelCase_     					=				do_normalize if do_normalize is not None else self.do_normalize
             UpperCAmelCase_     					=				image_mean if image_mean is not None else self.image_mean
             UpperCAmelCase_     					=				image_std if image_std is not None else self.image_std

             UpperCAmelCase_     					=				make_list_of_images(_UpperCAmelCase       )

             if not valid_images(_UpperCAmelCase       ):
                   raise ValueError(
                       "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
                       "torch.Tensor, tf.Tensor or jax.ndarray."       )

             if do_resize and size is None or resample is None:
                   raise ValueError("Size and resample must be specified if do_resize is True."       )

             if do_rescale and rescale_factor is None:
                   raise ValueError("Rescale factor must be specified if do_rescale is True."       )

             if do_normalize and (image_mean is None or image_std is None):
                   raise ValueError("Image mean and std must be specified if do_normalize is True."       )

             # All transformations expect numpy arrays.
             UpperCAmelCase_     					=				[to_numpy_array(_UpperCAmelCase       ) for image in images]

             if do_resize:
                   UpperCAmelCase_     					=				[self.resize(image=_UpperCAmelCase						,							size=_UpperCAmelCase						,							resample=_UpperCAmelCase       ) for image in images]

             if do_rescale:
                   UpperCAmelCase_     					=				[self.rescale(image=_UpperCAmelCase						,							scale=_UpperCAmelCase       ) for image in images]

             if do_normalize:
                   UpperCAmelCase_     					=				[self.normalize(image=_UpperCAmelCase						,							mean=_UpperCAmelCase						,							std=_UpperCAmelCase       ) for image in images]

             UpperCAmelCase_     					=				[to_channel_dimension_format(_UpperCAmelCase						,							_UpperCAmelCase       ) for image in images]

             UpperCAmelCase_     					=				{"pixel_values": images}
             return BatchFeature(data=_UpperCAmelCase						,							tensor_type=_UpperCAmelCase       )







       def 	lowercase__							(				self     :    Union[str, Any]						,							_UpperCAmelCase     :    Optional[int]						,							_UpperCAmelCase     :    List[Tuple] = None       )					->		int:


             '''simple docstring'''




             UpperCAmelCase_     					=				outputs.logits

             # Resize logits and compute semantic segmentation maps
             if target_sizes is not None:
                   if len(_UpperCAmelCase       ) != len(_UpperCAmelCase       ):
                         raise ValueError(
                             "Make sure that you pass in as many target sizes as the batch dimension of the logits"       )

                   if is_torch_tensor(_UpperCAmelCase       ):
                         UpperCAmelCase_     					=				target_sizes.numpy()

                   UpperCAmelCase_     					=				[]

                   for idx in range(len(_UpperCAmelCase       )       ):
                         UpperCAmelCase_     					=				torch.nn.functional.interpolate(
                             logits[idx].unsqueeze(dim=0       )						,							size=target_sizes[idx]						,							mode="bilinear"						,							align_corners=_UpperCAmelCase       )
                         UpperCAmelCase_     					=				resized_logits[0].argmax(dim=0       )
                         semantic_segmentation.append(_UpperCAmelCase       )
             else:
                   UpperCAmelCase_     					=				logits.argmax(dim=1       )
                   UpperCAmelCase_     					=				[semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]       )]

             return semantic_segmentation






import inspect
import unittest

from transformers import ViTMSNConfig
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 torch import nn

			from transformers import ViTMSNForImageClassification, ViTMSNModel
			from transformers.models.vit_msn.modeling_vit_msn import VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from PIL import Image

			from transformers import ViTImageProcessor





class       _lowerCAmelCase   :




				def __init__(   self							,							_UpperCamelCase							,							_UpperCamelCase=13							,							_UpperCamelCase=30							,							_UpperCamelCase=2							,							_UpperCamelCase=3							,							_UpperCamelCase=True							,							_UpperCamelCase=True							,							_UpperCamelCase=32							,							_UpperCamelCase=5							,							_UpperCamelCase=4							,							_UpperCamelCase=37							,							_UpperCamelCase="gelu"							,							_UpperCamelCase=0.1							,							_UpperCamelCase=0.1							,							_UpperCamelCase=10							,							_UpperCamelCase=0.02							,							_UpperCamelCase=None							,							)							-> List[Any]:
							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_         =      scope

							# in ViT MSN, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
							lowerCAmelCase_         =      (image_size // patch_size) ** 2
							lowerCAmelCase_         =      num_patches + 1




				def 	__a		(   self	)							-> Union[str, Any]:
							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 	__a		(   self	)							-> Optional[Any]:
							return ViTMSNConfig(
							    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							,							initializer_range=self.initializer_range							,							)




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase	)							-> str:
							lowerCAmelCase_         =      ViTMSNModel(config=_UpperCamelCase	)
							model.to(_UpperCamelCase	)
							model.eval()
							lowerCAmelCase_         =      model(_UpperCamelCase	)
							self.parent.assertEqual(result.last_hidden_state.shape							,							(self.batch_size, self.seq_length, self.hidden_size)	)




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase	)							-> str:
							lowerCAmelCase_         =      self.type_sequence_label_size
							lowerCAmelCase_         =      ViTMSNForImageClassification(_UpperCamelCase	)
							model.to(_UpperCamelCase	)
							model.eval()
							lowerCAmelCase_         =      model(_UpperCamelCase							,							labels=_UpperCamelCase	)
							print("Pixel and labels shape: {pixel_values.shape}, {labels.shape}"	)
							print("Labels: {labels}"	)
							self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.type_sequence_label_size)	)

							# test greyscale images
							lowerCAmelCase_         =      1
							lowerCAmelCase_         =      ViTMSNForImageClassification(_UpperCamelCase	)
							model.to(_UpperCamelCase	)
							model.eval()

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




				def 	__a		(   self	)							-> Union[str, Any]:
							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   (      __a   , __a   , unittest.TestCase			):
				_lowercase     						=(ViTMSNModel, ViTMSNForImageClassification) if is_torch_available() else ()
				_lowercase     						=(
				    {'''feature-extraction''': ViTMSNModel, '''image-classification''': ViTMSNForImageClassification}
				    if is_torch_available()
				    else {}
				)

				_lowercase     						=False
				_lowercase     						=False
				_lowercase     						=False
				_lowercase     						=False




				def 	__a		(   self	)							-> Optional[int]:
							lowerCAmelCase_         =      ViTMSNModelTester(self	)
							lowerCAmelCase_         =      ConfigTester(self							,							config_class=_UpperCamelCase							,							has_text_modality=_UpperCamelCase							,							hidden_size=37	)




				def 	__a		(   self	)							-> Optional[int]:
							self.config_tester.run_common_tests()




				@unittest.skip(reason="ViTMSN does not use inputs_embeds"	)
				def 	__a		(   self	)							-> str:
							pass




				def 	__a		(   self	)							-> Any:
							lowerCAmelCase_      ,    lowerCAmelCase_         =      self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
										lowerCAmelCase_         =      model_class(_UpperCamelCase	)
										self.assertIsInstance(model.get_input_embeddings()							,							(nn.Module)	)
										lowerCAmelCase_         =      model.get_output_embeddings()
										self.assertTrue(x is None or isinstance(_UpperCamelCase							,							nn.Linear	)	)




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

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




				def 	__a		(   self	)							-> str:
							lowerCAmelCase_         =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_UpperCamelCase	)




				def 	__a		(   self	)							-> Any:
							lowerCAmelCase_         =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*_UpperCamelCase	)




				@slow
				def 	__a		(   self	)							-> Union[str, Any]:
							for model_name in VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowerCAmelCase_         =      ViTMSNModel.from_pretrained(_UpperCamelCase	)
										self.assertIsNotNone(_UpperCamelCase	)






def   lowerCamelCase__							(							):




			"""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 	__a		(   self	)							-> List[str]:
							return ViTImageProcessor.from_pretrained("facebook/vit-msn-small"	) if is_vision_available() else None




				@slow
				def 	__a		(   self	)							-> int:
							torch.manual_seed(2	)
							lowerCAmelCase_         =      ViTMSNForImageClassification.from_pretrained("facebook/vit-msn-small"	).to(_UpperCamelCase	)

							lowerCAmelCase_         =      self.default_image_processor
							lowerCAmelCase_         =      prepare_img()
							lowerCAmelCase_         =      image_processor(images=_UpperCamelCase							,							return_tensors="pt"	).to(_UpperCamelCase	)

							# forward pass
							with torch.no_grad():
										lowerCAmelCase_         =      model(**_UpperCamelCase	)

							# verify the logits
							lowerCAmelCase_         =      torch.Size((1, 1_000)	)
							self.assertEqual(outputs.logits.shape							,							_UpperCamelCase	)

							lowerCAmelCase_         =      torch.tensor([-0.0803, -0.4454, -0.2375]	).to(_UpperCamelCase	)

							self.assertTrue(torch.allclose(outputs.logits[0, :3]							,							_UpperCamelCase							,							atol=1e-4	)	)



