

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

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    flip_channel_order,
    get_resize_output_image_size,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, is_vision_available, logging


if is_vision_available():
  import PIL

if is_torch_available():
  import torch


__UpperCAmelCase    				=     logging.get_logger(__name__)





class A__    ( A ):



 """simple docstring"""







 _lowercase     :					List[Any]      =						['''pixel_values''']

 def __init__(		self :	Tuple     ,						A_ :	bool = True     ,						A_ :	Dict[str, int] = None     ,						A_ :	PILImageResampling = PILImageResampling.BILINEAR     ,						A_ :	bool = True     ,						A_ :	Union[int, float] = 1 / 2_5_5     ,						A_ :	bool = True     ,						A_ :	Dict[str, int] = None     ,						A_ :	bool = True     ,						**A_ :	List[Any]     ,						):






      '''simple docstring'''




      super().__init__(**A_       )
      _lowerCAmelCase   :					Optional[int]        =    size if size is not None else {"shortest_edge": 2_2_4}
      _lowerCAmelCase   :					Optional[int]        =    get_size_dict(A_     ,						default_to_square=A_       )
      _lowerCAmelCase   :					Any        =    crop_size if crop_size is not None else {"height": 2_5_6, "width": 2_5_6}
      _lowerCAmelCase   :					str        =    get_size_dict(A_     ,						param_name="crop_size"       )

      _lowerCAmelCase   :					Any        =    do_resize
      _lowerCAmelCase   :					Optional[Any]        =    size
      _lowerCAmelCase   :					str        =    resample
      _lowerCAmelCase   :					Optional[Any]        =    do_rescale
      _lowerCAmelCase   :					Dict        =    rescale_factor
      _lowerCAmelCase   :					Any        =    do_center_crop
      _lowerCAmelCase   :					List[Any]        =    crop_size
      _lowerCAmelCase   :					List[Any]        =    do_flip_channel_order

 def    __magic_name__       (		self :	Tuple     ,						A_ :	np.ndarray     ,						A_ :	Dict[str, int]     ,						A_ :	PILImageResampling = PIL.Image.BILINEAR     ,						A_ :	Optional[Union[str, ChannelDimension]] = None     ,						**A_ :	Dict     ,						):






      '''simple docstring'''




      _lowerCAmelCase   :					Any        =    get_size_dict(A_     ,						default_to_square=A_       )
      if "shortest_edge" not in size:
           raise ValueError(F'''The `size` dictionary must contain the key `shortest_edge`. Got {size.keys()}'''       )
      _lowerCAmelCase   :					Union[str, Any]        =    get_resize_output_image_size(A_     ,						size=size["shortest_edge"]     ,						default_to_square=A_       )
      return resize(A_     ,						size=A_     ,						resample=A_     ,						data_format=A_     ,						**A_       )

 def    __magic_name__       (		self :	Union[str, Any]     ,						A_ :	np.ndarray     ,						A_ :	Dict[str, int]     ,						A_ :	Optional[Union[str, ChannelDimension]] = None     ,						**A_ :	List[str]     ,						):






      '''simple docstring'''




      _lowerCAmelCase   :					str        =    get_size_dict(A_       )
      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()}'''       )
      return center_crop(A_     ,						size=(size["height"], size["width"])     ,						data_format=A_     ,						**A_       )

 def    __magic_name__       (		self :	Tuple     ,						A_ :	np.ndarray     ,						A_ :	Union[int, float]     ,						A_ :	Optional[Union[str, ChannelDimension]] = None     ,						**A_ :	Any     ,						):






      '''simple docstring'''




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

 def    __magic_name__       (		self :	Optional[Any]     ,						A_ :	np.ndarray     ,						A_ :	Optional[Union[str, ChannelDimension]] = None       ):






      '''simple docstring'''




      return flip_channel_order(A_     ,						data_format=A_       )

 def    __magic_name__       (		self :	List[Any]     ,						A_ :	ImageInput     ,						A_ :	bool = None     ,						A_ :	Dict[str, int] = None     ,						A_ :	PILImageResampling = None     ,						A_ :	bool = None     ,						A_ :	float = None     ,						A_ :	bool = None     ,						A_ :	Dict[str, int] = None     ,						A_ :	bool = None     ,						A_ :	Optional[Union[str, TensorType]] = None     ,						A_ :	ChannelDimension = ChannelDimension.FIRST     ,						**A_ :	Tuple     ,						):






      '''simple docstring'''




      _lowerCAmelCase   :					str        =    do_resize if do_resize is not None else self.do_resize
      _lowerCAmelCase   :					Dict        =    resample if resample is not None else self.resample
      _lowerCAmelCase   :					str        =    do_rescale if do_rescale is not None else self.do_rescale
      _lowerCAmelCase   :					List[Any]        =    rescale_factor if rescale_factor is not None else self.rescale_factor
      _lowerCAmelCase   :					Tuple        =    do_center_crop if do_center_crop is not None else self.do_center_crop
      _lowerCAmelCase   :					str        =    (
          do_flip_channel_order if do_flip_channel_order is not None else self.do_flip_channel_order
      )

      _lowerCAmelCase   :					str        =    size if size is not None else self.size
      _lowerCAmelCase   :					str        =    get_size_dict(A_     ,						default_to_square=A_       )
      _lowerCAmelCase   :					Optional[Any]        =    crop_size if crop_size is not None else self.crop_size
      _lowerCAmelCase   :					List[str]        =    get_size_dict(A_     ,						param_name="crop_size"       )

      _lowerCAmelCase   :					Dict        =    make_list_of_images(A_       )

      if not valid_images(A_       ):
           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:
           raise ValueError("Size 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_center_crop and crop_size is None:
           raise ValueError("Crop size must be specified if do_center_crop is True."       )

      # All transformations expect numpy arrays.
      _lowerCAmelCase   :					Optional[int]        =    [to_numpy_array(A_       ) for image in images]

      if do_resize:
           _lowerCAmelCase   :					Any        =    [self.resize(image=A_     ,						size=A_     ,						resample=A_       ) for image in images]

      if do_center_crop:
           _lowerCAmelCase   :					Tuple        =    [self.center_crop(image=A_     ,						size=A_       ) for image in images]

      if do_rescale:
           _lowerCAmelCase   :					Any        =    [self.rescale(image=A_     ,						scale=A_       ) for image in images]

      # the pretrained checkpoints assume images are BGR, not RGB
      if do_flip_channel_order:
           _lowerCAmelCase   :					Dict        =    [self.flip_channel_order(image=A_       ) for image in images]

      _lowerCAmelCase   :					Optional[Any]        =    [to_channel_dimension_format(A_     ,						A_       ) for image in images]

      _lowerCAmelCase   :					Tuple        =    {"pixel_values": images}
      return BatchFeature(data=A_     ,						tensor_type=A_       )


 def    __magic_name__       (		self :	List[Any]     ,						A_ :	Union[str, Any]     ,						A_ :	List[Tuple] = None       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Union[str, Any]        =    outputs.logits

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

           if is_torch_tensor(A_       ):
                _lowerCAmelCase   :					Dict        =    target_sizes.numpy()

           _lowerCAmelCase   :					List[Any]        =    []

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

      return semantic_segmentation









from __future__ import annotations

import inspect
import unittest
from math import floor

import numpy as np

from transformers import CvtConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import TFCvtForImageClassification, TFCvtModel
  from transformers.models.cvt.modeling_tf_cvt import TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor





class A__    ( A ):



 """simple docstring"""







 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					int        =    self.config_class(**self.inputs_dict       )
      self.parent.assertTrue(hasattr(A_     ,						"embed_dim"       )       )
      self.parent.assertTrue(hasattr(A_     ,						"num_heads"       )       )





class A__    :



 """simple docstring"""







 def __init__(		self :	Tuple     ,						A_ :	int     ,						A_ :	Dict=1_3     ,						A_ :	int=6_4     ,						A_ :	str=3     ,						A_ :	Optional[int]=[1_6, 4_8, 9_6]     ,						A_ :	int=[1, 3, 6]     ,						A_ :	Optional[int]=[1, 2, 1_0]     ,						A_ :	Any=[7, 3, 3]     ,						A_ :	Tuple=[4, 2, 2]     ,						A_ :	str=[2, 1, 1]     ,						A_ :	Optional[Any]=[2, 2, 2]     ,						A_ :	Union[str, Any]=[False, False, True]     ,						A_ :	Union[str, Any]=[0.0, 0.0, 0.0]     ,						A_ :	Any=0.02     ,						A_ :	Optional[int]=1E-12     ,						A_ :	str=True     ,						A_ :	List[Any]=True     ,						A_ :	Union[str, Any]=2     ,						):






      '''simple docstring'''




      _lowerCAmelCase   :					Dict        =    parent
      _lowerCAmelCase   :					int        =    batch_size
      _lowerCAmelCase   :					Union[str, Any]        =    image_size
      _lowerCAmelCase   :					Optional[Any]        =    patch_sizes
      _lowerCAmelCase   :					Optional[int]        =    patch_stride
      _lowerCAmelCase   :					List[str]        =    patch_padding
      _lowerCAmelCase   :					str        =    is_training
      _lowerCAmelCase   :					Any        =    use_labels
      _lowerCAmelCase   :					Dict        =    num_labels
      _lowerCAmelCase   :					Tuple        =    num_channels
      _lowerCAmelCase   :					Tuple        =    embed_dim
      _lowerCAmelCase   :					List[Any]        =    num_heads
      _lowerCAmelCase   :					Union[str, Any]        =    stride_kv
      _lowerCAmelCase   :					Tuple        =    depth
      _lowerCAmelCase   :					List[str]        =    cls_token
      _lowerCAmelCase   :					Tuple        =    attention_drop_rate
      _lowerCAmelCase   :					Optional[Any]        =    initializer_range
      _lowerCAmelCase   :					Optional[int]        =    layer_norm_eps

 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      _lowerCAmelCase   :					str        =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

      _lowerCAmelCase   :					int        =    None
      if self.use_labels:
           # create a random int32 tensor of given shape
           _lowerCAmelCase   :					List[Any]        =    ids_tensor([self.batch_size]     ,						self.num_labels       )

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

 def    __magic_name__       (		self :	Union[str, Any]       ):






      '''simple docstring'''




      return CvtConfig(
          image_size=self.image_size     ,						num_labels=self.num_labels     ,						num_channels=self.num_channels     ,						embed_dim=self.embed_dim     ,						num_heads=self.num_heads     ,						patch_sizes=self.patch_sizes     ,						patch_padding=self.patch_padding     ,						patch_stride=self.patch_stride     ,						stride_kv=self.stride_kv     ,						depth=self.depth     ,						cls_token=self.cls_token     ,						attention_drop_rate=self.attention_drop_rate     ,						initializer_range=self.initializer_range     ,						)

 def    __magic_name__       (		self :	Union[str, Any]     ,						A_ :	str     ,						A_ :	Optional[int]     ,						A_ :	str       ):






      '''simple docstring'''




      _lowerCAmelCase   :					str        =    TFCvtModel(config=A_       )
      _lowerCAmelCase   :					str        =    model(A_     ,						training=A_       )
      _lowerCAmelCase   :					List[Any]        =    (self.image_size, self.image_size)
      _lowerCAmelCase      ,			_lowerCAmelCase   :					Any        =    image_size[0], image_size[1]
      for i in range(len(self.depth       )       ):
           _lowerCAmelCase   :					Union[str, Any]        =    floor(((height + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1       )
           _lowerCAmelCase   :					List[Any]        =    floor(((width + 2 * self.patch_padding[i] - self.patch_sizes[i]) / self.patch_stride[i]) + 1       )
      self.parent.assertEqual(result.last_hidden_state.shape     ,						(self.batch_size, self.embed_dim[-1], height, width)       )

 def    __magic_name__       (		self :	Any     ,						A_ :	Tuple     ,						A_ :	int     ,						A_ :	Any       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    self.num_labels
      _lowerCAmelCase   :					Optional[Any]        =    TFCvtForImageClassification(A_       )
      _lowerCAmelCase   :					Optional[Any]        =    model(A_     ,						labels=A_     ,						training=A_       )
      self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.num_labels)       )


 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




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





@require_tf
class A__    ( A  ,		A  ,		unittest.TestCase ):



 """simple docstring"""







 _lowercase     :					Any      =						(TFCvtModel, TFCvtForImageClassification) if is_tf_available() else ()
 _lowercase     :					Tuple      =						(
     {'''feature-extraction''': TFCvtModel, '''image-classification''': TFCvtForImageClassification}
     if is_tf_available()
     else {}
 )
 _lowercase     :					Optional[int]      =						False
 _lowercase     :					Any      =						False
 _lowercase     :					int      =						False
 _lowercase     :					int      =						False
 _lowercase     :					Tuple      =						False

 def    __magic_name__       (		self :	Optional[Any]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					List[Any]        =    TFCvtModelTester(self       )
      _lowerCAmelCase   :					Optional[Any]        =    TFCvtConfigTester(self     ,						config_class=A_     ,						has_text_modality=A_     ,						hidden_size=3_7       )

 def    __magic_name__       (		self :	List[Any]       ):






      '''simple docstring'''




      self.config_tester.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()

 @unittest.skip(reason="Cvt does not output attentions"       )
 def    __magic_name__       (		self :	str       ):






      '''simple docstring'''




      pass

 @unittest.skip(reason="Cvt does not use inputs_embeds"       )
 def    __magic_name__       (		self :	Tuple       ):






      '''simple docstring'''




      pass

 @unittest.skip(reason="Cvt does not support input and output embeddings"       )
 def    __magic_name__       (		self :	int       ):






      '''simple docstring'''




      pass

 @unittest.skipIf(
     not is_tf_available() or len(tf.config.list_physical_devices("GPU"       )       ) == 0     ,						reason="TF does not support backprop for grouped convolutions on CPU."     ,						)
 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      super().test_dataset_conversion()

 @unittest.skipIf(
     not is_tf_available() or len(tf.config.list_physical_devices("GPU"       )       ) == 0     ,						reason="TF does not support backprop for grouped convolutions on CPU."     ,						)
 @slow
 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      super().test_keras_fit()

 @unittest.skip(reason="Get `Failed to determine best cudnn convolution algo.` error after using TF 2.12+cuda 11.8"       )
 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    tf.keras.mixed_precision.Policy("mixed_float16"       )
      tf.keras.mixed_precision.set_global_policy(A_       )
      super().test_keras_fit()
      tf.keras.mixed_precision.set_global_policy("float32"       )

 def    __magic_name__       (		self :	str       ):






      '''simple docstring'''




      _lowerCAmelCase      ,			_lowerCAmelCase   :					List[Any]        =    self.model_tester.prepare_config_and_inputs_for_common()

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

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

 def    __magic_name__       (		self :	int       ):






      '''simple docstring'''




      def check_hidden_states_output(A_ :	Any     ,						A_ :	Any     ,						A_ :	Dict       ):
           _lowerCAmelCase   :					Tuple        =    model_class(A_       )

           _lowerCAmelCase   :					List[Any]        =    model(**self._prepare_for_class(A_     ,						A_       )       )
           _lowerCAmelCase   :					Tuple        =    outputs.hidden_states

           _lowerCAmelCase   :					Optional[Any]        =    len(self.model_tester.depth       )
           self.assertEqual(len(A_       )     ,						A_       )

           # verify the first hidden states (first block)
           self.assertListEqual(
               list(hidden_states[0].shape[-3:]       )     ,						[
                   self.model_tester.embed_dim[0],
                   self.model_tester.image_size // 4,
                   self.model_tester.image_size // 4,
               ]     ,						)

      _lowerCAmelCase      ,			_lowerCAmelCase   :					Tuple        =    self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           _lowerCAmelCase   :					Union[str, Any]        =    True
           check_hidden_states_output(A_     ,						A_     ,						A_       )

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

           check_hidden_states_output(A_     ,						A_     ,						A_       )

 def    __magic_name__       (		self :	Tuple       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Tuple        =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*A_       )

 def    __magic_name__       (		self :	List[str]       ):






      '''simple docstring'''




      _lowerCAmelCase   :					List[Any]        =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*A_       )


 @slow
 def    __magic_name__       (		self :	Dict       ):






      '''simple docstring'''




      for model_name in TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _lowerCAmelCase   :					Optional[Any]        =    TFCvtModel.from_pretrained(A_       )
           self.assertIsNotNone(A_       )







def 	_snake_case		(    )       ->      Dict:

     """simple docstring"""







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





@require_tf
@require_vision
class A__    ( unittest.TestCase ):



 """simple docstring"""







 @cached_property
 def    __magic_name__       (		self :	str       ):






      '''simple docstring'''




      return AutoImageProcessor.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )


 @slow
 def    __magic_name__       (		self :	int       ):






      '''simple docstring'''




      _lowerCAmelCase   :					Optional[int]        =    TFCvtForImageClassification.from_pretrained(TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )

      _lowerCAmelCase   :					int        =    self.default_image_processor
      _lowerCAmelCase   :					Optional[Any]        =    prepare_img()
      _lowerCAmelCase   :					Optional[Any]        =    image_processor(images=A_     ,						return_tensors="tf"       )

      # forward pass
      _lowerCAmelCase   :					str        =    model(**A_       )

      # verify the logits
      _lowerCAmelCase   :					List[str]        =    tf.TensorShape((1, 1_0_0_0)       )
      self.assertEqual(outputs.logits.shape     ,						A_       )

      _lowerCAmelCase   :					Any        =    tf.constant([0.9285, 0.9015, -0.3150]       )
      self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()     ,						A_     ,						atol=1E-4       )       )






