


"""simple docstring"""




from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFImageClassifierOutputWithNoAttention,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_resnet import ResNetConfig


lowerCAmelCase__						=			logging.get_logger(__name__)

# General docstring
lowerCAmelCase__						=			"ResNetConfig"

# Base docstring
lowerCAmelCase__						=			"microsoft/resnet-50"
lowerCAmelCase__						=			[1, 20_48, 7, 7]

# Image classification docstring
lowerCAmelCase__						=			"microsoft/resnet-50"
lowerCAmelCase__						=			"tiger cat"

lowerCAmelCase__						=			[
    "microsoft/resnet-50",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]







class 					lowerCAmelCase__	(    tf.keras.layers.Layer):




     '''simple docstring'''


     def __init__(						self			,						__lowerCamelCase			,						__lowerCamelCase = 3			,						__lowerCamelCase = 1			,						__lowerCamelCase = "relu"			,						**__lowerCamelCase)      ->    Tuple:
            super().__init__(**UpperCamelCase_)
            _A				:	List[Any]       =			kernel_size // 2
            _A				:	Optional[Any]       =			tf.keras.layers.ConvaD(
                UpperCamelCase_			,						kernel_size=UpperCamelCase_			,						strides=UpperCamelCase_			,						padding="valid"			,						use_bias=UpperCamelCase_			,						name="convolution")
            # Use same default momentum and epsilon as PyTorch equivalent
            _A				:	Tuple       =			tf.keras.layers.BatchNormalization(epsilon=1e-5			,						momentum=0.9			,						name="normalization")
            _A				:	Tuple       =			ACTaFN[activation] if activation is not None else tf.keras.layers.Activation("linear")


     def 			_lowerCamelCase			(						self			,						__lowerCamelCase)      ->    str:
            _A				:	str       =			(self.pad_value, self.pad_value)
            _A				:	Union[str, Any]       =			tf.pad(UpperCamelCase_			,						[(0, 0), height_pad, width_pad, (0, 0)])
            _A				:	Union[str, Any]       =			self.conv(UpperCamelCase_)
            return hidden_state


     def 			_lowerCamelCase			(						self			,						__lowerCamelCase			,						__lowerCamelCase = False)      ->    Dict:
            _A				:	Any       =			self.convolution(UpperCamelCase_)
            _A				:	Optional[int]       =			self.normalization(UpperCamelCase_			,						training=UpperCamelCase_)
            _A				:	List[Any]       =			self.activation(UpperCamelCase_)
            return hidden_state







class 					lowerCAmelCase__	(    tf.keras.layers.Layer):




     '''simple docstring'''


     def __init__(						self			,						__lowerCamelCase			,						**__lowerCamelCase)      ->    Dict:
            super().__init__(**UpperCamelCase_)
            _A				:	Tuple       =			TFResNetConvLayer(
                config.embedding_size			,						kernel_size=7			,						stride=2			,						activation=config.hidden_act			,						name="embedder"			,						)
            _A				:	int       =			tf.keras.layers.MaxPoolaD(pool_size=3			,						strides=2			,						padding="valid"			,						name="pooler")
            _A				:	Any       =			config.num_channels


     def 			_lowerCamelCase			(						self			,						__lowerCamelCase			,						__lowerCamelCase = False)      ->    str:
            _A   ,      _A   ,      _A   ,      _A				:	List[str]       =			shape_list(UpperCamelCase_)
            if tf.executing_eagerly() and num_channels != self.num_channels:
                   raise ValueError(
                       "Make sure that the channel dimension of the pixel values match with the one set in the configuration.")
            _A				:	Dict       =			pixel_values
            _A				:	Optional[int]       =			self.embedder(UpperCamelCase_)
            _A				:	str       =			tf.pad(UpperCamelCase_			,						[[0, 0], [1, 1], [1, 1], [0, 0]])
            _A				:	str       =			self.pooler(UpperCamelCase_)
            return hidden_state







class 					lowerCAmelCase__	(    tf.keras.layers.Layer):




     '''simple docstring'''


     def __init__(						self			,						__lowerCamelCase			,						__lowerCamelCase = 2			,						**__lowerCamelCase)      ->    List[str]:
            super().__init__(**UpperCamelCase_)
            _A				:	Dict       =			tf.keras.layers.ConvaD(
                UpperCamelCase_			,						kernel_size=1			,						strides=UpperCamelCase_			,						use_bias=UpperCamelCase_			,						name="convolution")
            # Use same default momentum and epsilon as PyTorch equivalent
            _A				:	Union[str, Any]       =			tf.keras.layers.BatchNormalization(epsilon=1e-5			,						momentum=0.9			,						name="normalization")


     def 			_lowerCamelCase			(						self			,						__lowerCamelCase			,						__lowerCamelCase = False)      ->    Any:
            _A				:	str       =			x
            _A				:	Optional[Any]       =			self.convolution(UpperCamelCase_)
            _A				:	Tuple       =			self.normalization(UpperCamelCase_			,						training=UpperCamelCase_)
            return hidden_state







class 					lowerCAmelCase__	(    tf.keras.layers.Layer):




     '''simple docstring'''


     def __init__(						self			,						__lowerCamelCase			,						__lowerCamelCase			,						__lowerCamelCase = 1			,						__lowerCamelCase = "relu"			,						**__lowerCamelCase)      ->    Tuple:
            super().__init__(**UpperCamelCase_)
            _A				:	int       =			in_channels != out_channels or stride != 1
            _A				:	List[str]       =			TFResNetConvLayer(UpperCamelCase_			,						stride=UpperCamelCase_			,						name="layer.0")
            _A				:	Optional[int]       =			TFResNetConvLayer(UpperCamelCase_			,						activation=UpperCamelCase_			,						name="layer.1")
            _A				:	Optional[int]       =			(
                TFResNetShortCut(UpperCamelCase_			,						stride=UpperCamelCase_			,						name="shortcut")
                if should_apply_shortcut
                else tf.keras.layers.Activation("linear"			,						name="shortcut")
            )
            _A				:	Optional[int]       =			ACTaFN[activation]


     def 			_lowerCamelCase			(						self			,						__lowerCamelCase			,						__lowerCamelCase = False)      ->    List[Any]:
            _A				:	List[str]       =			hidden_state
            _A				:	Optional[Any]       =			self.conva(UpperCamelCase_			,						training=UpperCamelCase_)
            _A				:	Any       =			self.conva(UpperCamelCase_			,						training=UpperCamelCase_)
            _A				:	List[Any]       =			self.shortcut(UpperCamelCase_			,						training=UpperCamelCase_)
            hidden_state += residual
            _A				:	List[Any]       =			self.activation(UpperCamelCase_)
            return hidden_state







class 					lowerCAmelCase__	(    tf.keras.layers.Layer):




     '''simple docstring'''


     def __init__(						self			,						__lowerCamelCase			,						__lowerCamelCase			,						__lowerCamelCase = 1			,						__lowerCamelCase = "relu"			,						__lowerCamelCase = 4			,						**__lowerCamelCase			,						)      ->    List[Any]:
            super().__init__(**UpperCamelCase_)
            _A				:	str       =			in_channels != out_channels or stride != 1
            _A				:	Optional[Any]       =			out_channels // reduction
            _A				:	Tuple       =			TFResNetConvLayer(UpperCamelCase_			,						kernel_size=1			,						name="layer.0")
            _A				:	Tuple       =			TFResNetConvLayer(UpperCamelCase_			,						stride=UpperCamelCase_			,						name="layer.1")
            _A				:	Any       =			TFResNetConvLayer(UpperCamelCase_			,						kernel_size=1			,						activation=UpperCamelCase_			,						name="layer.2")
            _A				:	Tuple       =			(
                TFResNetShortCut(UpperCamelCase_			,						stride=UpperCamelCase_			,						name="shortcut")
                if should_apply_shortcut
                else tf.keras.layers.Activation("linear"			,						name="shortcut")
            )
            _A				:	Optional[int]       =			ACTaFN[activation]


     def 			_lowerCamelCase			(						self			,						__lowerCamelCase			,						__lowerCamelCase = False)      ->    List[str]:
            _A				:	Union[str, Any]       =			hidden_state
            _A				:	Optional[int]       =			self.conva(UpperCamelCase_			,						training=UpperCamelCase_)
            _A				:	Any       =			self.conva(UpperCamelCase_			,						training=UpperCamelCase_)
            _A				:	Optional[int]       =			self.conva(UpperCamelCase_			,						training=UpperCamelCase_)
            _A				:	int       =			self.shortcut(UpperCamelCase_			,						training=UpperCamelCase_)
            hidden_state += residual
            _A				:	Optional[int]       =			self.activation(UpperCamelCase_)
            return hidden_state







class 					lowerCAmelCase__	(    tf.keras.layers.Layer):




     '''simple docstring'''


     def __init__(						self			,						__lowerCamelCase			,						__lowerCamelCase			,						__lowerCamelCase			,						__lowerCamelCase = 2			,						__lowerCamelCase = 2			,						**__lowerCamelCase)      ->    Any:
            super().__init__(**UpperCamelCase_)

            _A				:	Any       =			TFResNetBottleNeckLayer if config.layer_type == "bottleneck" else TFResNetBasicLayer

            _A				:	Dict       =			[layer(UpperCamelCase_			,						UpperCamelCase_			,						stride=UpperCamelCase_			,						activation=config.hidden_act			,						name="layers.0")]
            layers += [
                layer(UpperCamelCase_			,						UpperCamelCase_			,						activation=config.hidden_act			,						name=F"layers.{i + 1}")
                for i in range(depth - 1)
            ]
            _A				:	Dict       =			layers


     def 			_lowerCamelCase			(						self			,						__lowerCamelCase			,						__lowerCamelCase = False)      ->    Dict:



            for layer in self.stage_layers:
                   _A				:	str       =			layer(UpperCamelCase_			,						training=UpperCamelCase_)
            return hidden_state







class 					lowerCAmelCase__	(    tf.keras.layers.Layer):




     '''simple docstring'''


     def __init__(						self			,						__lowerCamelCase			,						**__lowerCamelCase)      ->    Optional[int]:
            super().__init__(**UpperCamelCase_)
            # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
            _A				:	Optional[Any]       =			[
                TFResNetStage(
                    UpperCamelCase_			,						config.embedding_size			,						config.hidden_sizes[0]			,						stride=2 if config.downsample_in_first_stage else 1			,						depth=config.depths[0]			,						name="stages.0"			,						)
            ]
            for i, (in_channels, out_channels, depth) in enumerate(
                zip(config.hidden_sizes			,						config.hidden_sizes[1:]			,						config.depths[1:])):
                   self.stages.append(TFResNetStage(UpperCamelCase_			,						UpperCamelCase_			,						UpperCamelCase_			,						depth=UpperCamelCase_			,						name=F"stages.{i + 1}"))


     def 			_lowerCamelCase			(						self			,						__lowerCamelCase			,						__lowerCamelCase = False			,						__lowerCamelCase = True			,						__lowerCamelCase = False			,						)      ->    Any:
            _A				:	List[Any]       =			() if output_hidden_states else None

            for stage_module in self.stages:
                   if output_hidden_states:
                          _A				:	Tuple       =			hidden_states + (hidden_state,)

                   _A				:	Any       =			stage_module(UpperCamelCase_			,						training=UpperCamelCase_)

            if output_hidden_states:
                   _A				:	int       =			hidden_states + (hidden_state,)

            if not return_dict:
                   return tuple(v for v in [hidden_state, hidden_states] if v is not None)

            return TFBaseModelOutputWithNoAttention(last_hidden_state=UpperCamelCase_			,						hidden_states=UpperCamelCase_)







class 					lowerCAmelCase__	(    lowercase_):




     '''simple docstring'''
     __SCREAMING_SNAKE_CASE        =			ResNetConfig
     __SCREAMING_SNAKE_CASE        =			"resnet"
     __SCREAMING_SNAKE_CASE        =			"pixel_values"


     @property
     def 			_lowerCamelCase			(						self)      ->    Union[str, Any]:
            return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_2_4, 2_2_4)			,						dtype=tf.floataa)}




lowerCAmelCase__						=			R"\n    This model is a TensorFlow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular TensorFlow Module and refer to the TensorFlow documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n"


lowerCAmelCase__						=			R"\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n"







@keras_serializable
class 					lowerCAmelCase__	(    tf.keras.layers.Layer):




     '''simple docstring'''
     __SCREAMING_SNAKE_CASE        =			ResNetConfig


     def __init__(						self			,						__lowerCamelCase			,						**__lowerCamelCase)      ->    str:
            super().__init__(**UpperCamelCase_)
            _A				:	int       =			config
            _A				:	List[Any]       =			TFResNetEmbeddings(UpperCamelCase_			,						name="embedder")
            _A				:	Union[str, Any]       =			TFResNetEncoder(UpperCamelCase_			,						name="encoder")
            _A				:	Dict       =			tf.keras.layers.GlobalAveragePoolingaD(keepdims=UpperCamelCase_)


     @unpack_inputs
     def 			_lowerCamelCase			(						self			,						__lowerCamelCase			,						__lowerCamelCase = None			,						__lowerCamelCase = None			,						__lowerCamelCase = False			,						)      ->    Optional[int]:
            _A				:	List[Any]       =			(
                output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
            )
            _A				:	int       =			return_dict if return_dict is not None else self.config.use_return_dict

            # TF 2.0 image layers can't use NCHW format when running on CPU.
            # We transpose to NHWC format and then transpose back after the full forward pass.
            # (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
            _A				:	Tuple       =			tf.transpose(UpperCamelCase_			,						perm=[0, 2, 3, 1])
            _A				:	str       =			self.embedder(UpperCamelCase_			,						training=UpperCamelCase_)

            _A				:	Dict       =			self.encoder(
                UpperCamelCase_			,						output_hidden_states=UpperCamelCase_			,						return_dict=UpperCamelCase_			,						training=UpperCamelCase_)

            _A				:	List[Any]       =			encoder_outputs[0]

            _A				:	Tuple       =			self.pooler(UpperCamelCase_)

            # Transpose all the outputs to the NCHW format
            # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
            _A				:	Tuple       =			tf.transpose(UpperCamelCase_			,						(0, 3, 1, 2))
            _A				:	Union[str, Any]       =			tf.transpose(UpperCamelCase_			,						(0, 3, 1, 2))
            _A				:	Dict       =			()
            for hidden_state in encoder_outputs[1:]:
                   _A				:	List[Any]       =			hidden_states + tuple(tf.transpose(UpperCamelCase_			,						(0, 3, 1, 2)) for h in hidden_state)

            if not return_dict:
                   return (last_hidden_state, pooled_output) + hidden_states

            _A				:	List[str]       =			hidden_states if output_hidden_states else None

            return TFBaseModelOutputWithPoolingAndNoAttention(
                last_hidden_state=UpperCamelCase_			,						pooler_output=UpperCamelCase_			,						hidden_states=UpperCamelCase_			,						)







@add_start_docstrings(
    "The bare ResNet model outputting raw features without any specific head on top."					,   lowercase_					,   )
class 					lowerCAmelCase__	(    lowercase_):




     '''simple docstring'''


     def __init__(						self			,						__lowerCamelCase			,						**__lowerCamelCase)      ->    Dict:
            super().__init__(UpperCamelCase_			,						**UpperCamelCase_)
            _A				:	Optional[int]       =			TFResNetMainLayer(config=UpperCamelCase_			,						name="resnet")


     @add_start_docstrings_to_model_forward(UpperCamelCase_)
     @add_code_sample_docstrings(
         checkpoint=_CHECKPOINT_FOR_DOC			,						output_type=UpperCamelCase_			,						config_class=_CONFIG_FOR_DOC			,						modality="vision"			,						expected_output=_EXPECTED_OUTPUT_SHAPE			,						)
     @unpack_inputs
     def 			_lowerCamelCase			(						self			,						__lowerCamelCase			,						__lowerCamelCase = None			,						__lowerCamelCase = None			,						__lowerCamelCase = False			,						)      ->    int:
            _A				:	Optional[int]       =			(
                output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
            )
            _A				:	Union[str, Any]       =			return_dict if return_dict is not None else self.config.use_return_dict

            _A				:	Dict       =			self.resnet(
                pixel_values=UpperCamelCase_			,						output_hidden_states=UpperCamelCase_			,						return_dict=UpperCamelCase_			,						training=UpperCamelCase_			,						)
            return resnet_outputs







@add_start_docstrings(
    "\n    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "					,   lowercase_					,   )
class 					lowerCAmelCase__	(    lowercase_					,   lowercase_):




     '''simple docstring'''


     def __init__(						self			,						__lowerCamelCase			,						**__lowerCamelCase)      ->    List[str]:
            super().__init__(UpperCamelCase_			,						**UpperCamelCase_)
            _A				:	Optional[int]       =			config.num_labels
            _A				:	Union[str, Any]       =			TFResNetMainLayer(UpperCamelCase_			,						name="resnet")
            # classification head
            _A				:	Any       =			(
                tf.keras.layers.Dense(config.num_labels			,						name="classifier.1")
                if config.num_labels > 0
                else tf.keras.layers.Activation("linear"			,						name="classifier.1")
            )


     def 			_lowerCamelCase			(						self			,						__lowerCamelCase)      ->    List[Any]:
            _A				:	Dict       =			tf.keras.layers.Flatten()(UpperCamelCase_)
            _A				:	int       =			self.classifier_layer(UpperCamelCase_)
            return logits


     @add_start_docstrings_to_model_forward(UpperCamelCase_)
     @add_code_sample_docstrings(
         checkpoint=_IMAGE_CLASS_CHECKPOINT			,						output_type=UpperCamelCase_			,						config_class=_CONFIG_FOR_DOC			,						expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT			,						)
     @unpack_inputs
     def 			_lowerCamelCase			(						self			,						__lowerCamelCase = None			,						__lowerCamelCase = None			,						__lowerCamelCase = None			,						__lowerCamelCase = None			,						__lowerCamelCase = False			,						)      ->    Optional[int]:
            _A				:	Tuple       =			return_dict if return_dict is not None else self.config.use_return_dict

            _A				:	Tuple       =			self.resnet(
                UpperCamelCase_			,						output_hidden_states=UpperCamelCase_			,						return_dict=UpperCamelCase_			,						training=UpperCamelCase_)

            _A				:	Optional[int]       =			outputs.pooler_output if return_dict else outputs[1]

            _A				:	int       =			self.classifier(UpperCamelCase_)

            _A				:	Any       =			None if labels is None else self.hf_compute_loss(UpperCamelCase_			,						UpperCamelCase_)

            if not return_dict:
                   _A				:	Tuple       =			(logits,) + outputs[2:]
                   return (loss,) + output if loss is not None else output

            return TFImageClassifierOutputWithNoAttention(loss=UpperCamelCase_			,						logits=UpperCamelCase_			,						hidden_states=outputs.hidden_states)




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


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import SwinaSRImageProcessor
    from transformers.image_transforms import get_image_size







class 					lowerCAmelCase__	(    unittest.TestCase):




     '''simple docstring'''


     def __init__(						self			,						__lowerCamelCase			,						__lowerCamelCase=7			,						__lowerCamelCase=3			,						__lowerCamelCase=1_8			,						__lowerCamelCase=3_0			,						__lowerCamelCase=4_0_0			,						__lowerCamelCase=True			,						__lowerCamelCase=1 / 2_5_5			,						__lowerCamelCase=True			,						__lowerCamelCase=8			,						)      ->    Optional[Any]:
            _A				:	List[str]       =			parent
            _A				:	str       =			batch_size
            _A				:	Any       =			num_channels
            _A				:	Any       =			image_size
            _A				:	Optional[int]       =			min_resolution
            _A				:	Union[str, Any]       =			max_resolution
            _A				:	Optional[Any]       =			do_rescale
            _A				:	str       =			rescale_factor
            _A				:	str       =			do_pad
            _A				:	Dict       =			pad_size


     def 			_lowerCamelCase			(						self)      ->    str:
            return {
                "do_rescale": self.do_rescale,
                "rescale_factor": self.rescale_factor,
                "do_pad": self.do_pad,
                "pad_size": self.pad_size,
            }


     def 			_lowerCamelCase			(						self			,						__lowerCamelCase=False			,						__lowerCamelCase=False			,						__lowerCamelCase=False)      ->    str:
            assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

            if equal_resolution:
                   _A				:	List[str]       =			[]
                   for i in range(self.batch_size):
                          image_inputs.append(
                              np.random.randint(
                                  2_5_5			,						size=(self.num_channels, self.max_resolution, self.max_resolution)			,						dtype=np.uinta))
            else:
                   _A				:	List[str]       =			[]
                   for i in range(self.batch_size):
                          _A   ,      _A				:	int       =			np.random.choice(np.arange(self.min_resolution			,						self.max_resolution)			,						2)
                          image_inputs.append(np.random.randint(2_5_5			,						size=(self.num_channels, width, height)			,						dtype=np.uinta))

            if not numpify and not torchify:
                   # PIL expects the channel dimension as last dimension
                   _A				:	Optional[Any]       =			[Image.fromarray(np.moveaxis(__lowerCamelCase			,						0			,						-1)) for x in image_inputs]

            if torchify:
                   _A				:	Union[str, Any]       =			[torch.from_numpy(__lowerCamelCase) for x in image_inputs]

            return image_inputs







@require_torch
@require_vision
class 					lowerCAmelCase__	(    a					,   unittest.TestCase):




     '''simple docstring'''
     __SCREAMING_SNAKE_CASE        =			SwinaSRImageProcessor if is_vision_available() else None


     def 			_lowerCamelCase			(						self)      ->    Any:
            _A				:	int       =			SwinaSRImageProcessingTester(self)


     @property
     def 			_lowerCamelCase			(						self)      ->    Any:
            return self.image_processor_tester.prepare_image_processor_dict()


     def 			_lowerCamelCase			(						self)      ->    Union[str, Any]:
            _A				:	Tuple       =			self.image_processing_class(**self.image_processor_dict)
            self.assertTrue(hasattr(__lowerCamelCase			,						"do_rescale"))
            self.assertTrue(hasattr(__lowerCamelCase			,						"rescale_factor"))
            self.assertTrue(hasattr(__lowerCamelCase			,						"do_pad"))
            self.assertTrue(hasattr(__lowerCamelCase			,						"pad_size"))


     def 			_lowerCamelCase			(						self)      ->    Dict:
            pass


     def 			_lowerCamelCase			(						self			,						__lowerCamelCase)      ->    Tuple:
            _A   ,      _A				:	Dict       =			get_image_size(__lowerCamelCase)
            _A				:	Tuple       =			self.image_processor_tester.pad_size

            _A				:	Dict       =			(old_height // size + 1) * size - old_height
            _A				:	Any       =			(old_width // size + 1) * size - old_width
            return old_height + pad_height, old_width + pad_width


     def 			_lowerCamelCase			(						self)      ->    Dict:
            # Initialize image_processor
            _A				:	Optional[int]       =			self.image_processing_class(**self.image_processor_dict)
            # create random PIL images
            _A				:	Union[str, Any]       =			self.image_processor_tester.prepare_inputs(equal_resolution=__lowerCamelCase)
            for image in image_inputs:
                   self.assertIsInstance(__lowerCamelCase			,						Image.Image)

            # Test not batched input
            _A				:	str       =			image_processor(image_inputs[0]			,						return_tensors="pt").pixel_values
            _A   ,      _A				:	int       =			self.calculate_expected_size(np.array(image_inputs[0]))
            self.assertEqual(
                encoded_images.shape			,						(
                    1,
                    self.image_processor_tester.num_channels,
                    expected_height,
                    expected_width,
                )			,						)


     def 			_lowerCamelCase			(						self)      ->    int:
            # Initialize image_processor
            _A				:	Any       =			self.image_processing_class(**self.image_processor_dict)
            # create random numpy tensors
            _A				:	int       =			self.image_processor_tester.prepare_inputs(equal_resolution=__lowerCamelCase			,						numpify=__lowerCamelCase)
            for image in image_inputs:
                   self.assertIsInstance(__lowerCamelCase			,						np.ndarray)

            # Test not batched input
            _A				:	Union[str, Any]       =			image_processor(image_inputs[0]			,						return_tensors="pt").pixel_values
            _A   ,      _A				:	Union[str, Any]       =			self.calculate_expected_size(image_inputs[0])
            self.assertEqual(
                encoded_images.shape			,						(
                    1,
                    self.image_processor_tester.num_channels,
                    expected_height,
                    expected_width,
                )			,						)


     def 			_lowerCamelCase			(						self)      ->    Optional[Any]:
            # Initialize image_processor
            _A				:	str       =			self.image_processing_class(**self.image_processor_dict)
            # create random PyTorch tensors
            _A				:	Tuple       =			self.image_processor_tester.prepare_inputs(equal_resolution=__lowerCamelCase			,						torchify=__lowerCamelCase)
            for image in image_inputs:
                   self.assertIsInstance(__lowerCamelCase			,						torch.Tensor)

            # Test not batched input
            _A				:	List[str]       =			image_processor(image_inputs[0]			,						return_tensors="pt").pixel_values
            _A   ,      _A				:	List[str]       =			self.calculate_expected_size(image_inputs[0])
            self.assertEqual(
                encoded_images.shape			,						(
                    1,
                    self.image_processor_tester.num_channels,
                    expected_height,
                    expected_width,
                )			,						)
