





'''simple docstring'''





from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


__A             =       logging.get_logger(__name__)

__A             =       {
    "shi-labs/dinat-mini-in1k-224": "https://huggingface.co/shi-labs/dinat-mini-in1k-224/resolve/main/config.json",
    # See all Dinat models at https://huggingface.co/models?filter=dinat
}



class      _SCREAMING_SNAKE_CASE		(			__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE					):







 '''simple docstring'''
 lowercase_	=    'dinat'

 lowercase_	=    {
     'num_attention_heads': 'num_heads',
     'num_hidden_layers': 'num_layers',
 }

 def __init__(self       :     str ,				UpperCAmelCase_       :     Optional[int]=4 ,				UpperCAmelCase_       :     Optional[int]=3 ,				UpperCAmelCase_       :     Dict=64 ,				UpperCAmelCase_       :     List[Any]=[3, 4, 6, 5] ,				UpperCAmelCase_       :     Any=[2, 4, 8, 16] ,				UpperCAmelCase_       :     Dict=7 ,				UpperCAmelCase_       :     Optional[Any]=[[1, 8, 1], [1, 4, 1, 4], [1, 2, 1, 2, 1, 2], [1, 1, 1, 1, 1]] ,				UpperCAmelCase_       :     List[Any]=3.0 ,				UpperCAmelCase_       :     Optional[Any]=True ,				UpperCAmelCase_       :     Any=0.0 ,				UpperCAmelCase_       :     Optional[Any]=0.0 ,				UpperCAmelCase_       :     Tuple=0.1 ,				UpperCAmelCase_       :     Tuple="gelu" ,				UpperCAmelCase_       :     Optional[Any]=0.02 ,				UpperCAmelCase_       :     Tuple=1E-5 ,				UpperCAmelCase_       :     Any=0.0 ,				UpperCAmelCase_       :     List[str]=None ,				UpperCAmelCase_       :     List[str]=None ,				**UpperCAmelCase_       :     Dict ,				) ->Dict:



   '''simple docstring'''



   super().__init__(**_a)

   lowerCamelCase__:   Optional[Any]    						=patch_size
   lowerCamelCase__:   Union[str, Any]    						=num_channels
   lowerCamelCase__:   List[str]    						=embed_dim
   lowerCamelCase__:   Any    						=depths
   lowerCamelCase__:   str    						=len(_a)
   lowerCamelCase__:   int    						=num_heads
   lowerCamelCase__:   int    						=kernel_size
   lowerCamelCase__:   Tuple    						=dilations
   lowerCamelCase__:   List[str]    						=mlp_ratio
   lowerCamelCase__:   int    						=qkv_bias
   lowerCamelCase__:   Union[str, Any]    						=hidden_dropout_prob
   lowerCamelCase__:   Union[str, Any]    						=attention_probs_dropout_prob
   lowerCamelCase__:   List[str]    						=drop_path_rate
   lowerCamelCase__:   Tuple    						=hidden_act
   lowerCamelCase__:   List[str]    						=layer_norm_eps
   lowerCamelCase__:   Dict    						=initializer_range
   # we set the hidden_size attribute in order to make Dinat work with VisionEncoderDecoderModel
   # this indicates the channel dimension after the last stage of the model
   lowerCamelCase__:   Tuple    						=int(embed_dim * 2 ** (len(_a) - 1))
   lowerCamelCase__:   Union[str, Any]    						=layer_scale_init_value
   lowerCamelCase__:   int    						=["stem"] + [F"""stage{idx}""" for idx in range(1 ,				len(_a) + 1)]
   lowerCamelCase__						,      lowerCamelCase__:   List[str]    						=get_aligned_output_features_output_indices(
       out_features=_a ,				out_indices=_a ,				stage_names=self.stage_names)








from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import logging


if is_vision_available():
     import PIL

__A             =       logging.get_logger(__name__)





def   lowerCAmelCase_				( __a	)  ->	List[List[ImageInput]]:







  """simple docstring"""





  if isinstance(__a			,					(list, tuple)	) and isinstance(videos[0]			,					(list, tuple)	) and is_valid_image(videos[0][0]	):
    return videos

  elif isinstance(__a			,					(list, tuple)	) and is_valid_image(videos[0]	):
    return [videos]

  elif is_valid_image(__a	):
    return [[videos]]

  raise ValueError(F"""Could not make batched video from {videos}"""	)






class      _SCREAMING_SNAKE_CASE		(			__SCREAMING_SNAKE_CASE					):







 '''simple docstring'''
 lowercase_	=    ["pixel_values"]

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



   '''simple docstring'''



   super().__init__(**UpperCAmelCase_)
   lowerCamelCase__:   Optional[int]    						=size if size is not None else {"shortest_edge": 256}
   lowerCamelCase__:   Any    						=get_size_dict(UpperCAmelCase_ ,				default_to_square=UpperCAmelCase_)
   lowerCamelCase__:   Tuple    						=crop_size if crop_size is not None else {"height": 224, "width": 224}
   lowerCamelCase__:   Any    						=get_size_dict(UpperCAmelCase_ ,				param_name="crop_size")

   lowerCamelCase__:   str    						=do_resize
   lowerCamelCase__:   Any    						=size
   lowerCamelCase__:   Any    						=do_center_crop
   lowerCamelCase__:   int    						=crop_size
   lowerCamelCase__:   int    						=resample
   lowerCamelCase__:   Optional[int]    						=do_rescale
   lowerCamelCase__:   int    						=rescale_factor
   lowerCamelCase__:   Dict    						=offset
   lowerCamelCase__:   List[Any]    						=do_normalize
   lowerCamelCase__:   Optional[int]    						=image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
   lowerCamelCase__:   List[str]    						=image_std if image_std is not None else IMAGENET_STANDARD_STD

 def 							SCREAMING_SNAKE_CASE_      (self       :     Union[str, Any] ,				UpperCAmelCase_       :     np.ndarray ,				UpperCAmelCase_       :     Dict[str, int] ,				UpperCAmelCase_       :     PILImageResampling = PILImageResampling.BILINEAR ,				UpperCAmelCase_       :     Optional[Union[str, ChannelDimension]] = None ,				**UpperCAmelCase_       :     List[Any] ,				) ->np.ndarray:



   '''simple docstring'''



   lowerCamelCase__:   Dict    						=get_size_dict(UpperCAmelCase_ ,				default_to_square=UpperCAmelCase_)
   if "shortest_edge" in size:
     lowerCamelCase__:   Union[str, Any]    						=get_resize_output_image_size(UpperCAmelCase_ ,				size["shortest_edge"] ,				default_to_square=UpperCAmelCase_)
   elif "height" in size and "width" in size:
     lowerCamelCase__:   int    						=(size["height"], size["width"])
   else:
     raise ValueError(F"""Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}""")
   return resize(UpperCAmelCase_ ,				size=UpperCAmelCase_ ,				resample=UpperCAmelCase_ ,				data_format=UpperCAmelCase_ ,				**UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_      (self       :     str ,				UpperCAmelCase_       :     np.ndarray ,				UpperCAmelCase_       :     Dict[str, int] ,				UpperCAmelCase_       :     Optional[Union[str, ChannelDimension]] = None ,				**UpperCAmelCase_       :     List[Any] ,				) ->np.ndarray:



   '''simple docstring'''



   lowerCamelCase__:   List[str]    						=get_size_dict(UpperCAmelCase_)
   if "height" not in size or "width" not in size:
     raise ValueError(F"""Size must have 'height' and 'width' as keys. Got {size.keys()}""")
   return center_crop(UpperCAmelCase_ ,				size=(size["height"], size["width"]) ,				data_format=UpperCAmelCase_ ,				**UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_      (self       :     Union[str, Any] ,				UpperCAmelCase_       :     np.ndarray ,				UpperCAmelCase_       :     Union[int, float] ,				UpperCAmelCase_       :     bool = True ,				UpperCAmelCase_       :     Optional[Union[str, ChannelDimension]] = None ,				**UpperCAmelCase_       :     Union[str, Any] ,				) ->Union[str, Any]:



   '''simple docstring'''



   lowerCamelCase__:   str    						=image.astype(np.floataa)
   if offset:
     lowerCamelCase__:   List[Any]    						=image - (scale / 2)
   return rescale(UpperCAmelCase_ ,				scale=UpperCAmelCase_ ,				data_format=UpperCAmelCase_ ,				**UpperCAmelCase_)

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



   '''simple docstring'''



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

 def 							SCREAMING_SNAKE_CASE_      (self       :     Optional[int] ,				UpperCAmelCase_       :     ImageInput ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     Dict[str, int] = None ,				UpperCAmelCase_       :     PILImageResampling = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     Dict[str, int] = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     float = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     Optional[Union[float, List[float]]] = None ,				UpperCAmelCase_       :     Optional[Union[float, List[float]]] = None ,				UpperCAmelCase_       :     Optional[ChannelDimension] = ChannelDimension.FIRST ,				) ->np.ndarray:



   '''simple docstring'''



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

   if offset and not do_rescale:
     raise ValueError("For offset, do_rescale must also be set to True.")

   # All transformations expect numpy arrays.
   lowerCamelCase__:   List[str]    						=to_numpy_array(UpperCAmelCase_)

   if do_resize:
     lowerCamelCase__:   Optional[Any]    						=self.resize(image=UpperCAmelCase_ ,				size=UpperCAmelCase_ ,				resample=UpperCAmelCase_)

   if do_center_crop:
     lowerCamelCase__:   str    						=self.center_crop(UpperCAmelCase_ ,				size=UpperCAmelCase_)

   if do_rescale:
     lowerCamelCase__:   List[str]    						=self.rescale(image=UpperCAmelCase_ ,				scale=UpperCAmelCase_ ,				offset=UpperCAmelCase_)

   if do_normalize:
     lowerCamelCase__:   Dict    						=self.normalize(image=UpperCAmelCase_ ,				mean=UpperCAmelCase_ ,				std=UpperCAmelCase_)

   lowerCamelCase__:   Any    						=to_channel_dimension_format(UpperCAmelCase_ ,				UpperCAmelCase_)
   return image







 def 							SCREAMING_SNAKE_CASE_      (self       :     Optional[Any] ,				UpperCAmelCase_       :     ImageInput ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     Dict[str, int] = None ,				UpperCAmelCase_       :     PILImageResampling = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     Dict[str, int] = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     float = None ,				UpperCAmelCase_       :     bool = 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_       :     List[str] ,				) ->PIL.Image.Image:



   '''simple docstring'''



   lowerCamelCase__:   Union[str, Any]    						=do_resize if do_resize is not None else self.do_resize
   lowerCamelCase__:   Optional[int]    						=resample if resample is not None else self.resample
   lowerCamelCase__:   Optional[int]    						=do_center_crop if do_center_crop is not None else self.do_center_crop
   lowerCamelCase__:   List[str]    						=do_rescale if do_rescale is not None else self.do_rescale
   lowerCamelCase__:   Dict    						=rescale_factor if rescale_factor is not None else self.rescale_factor
   lowerCamelCase__:   Union[str, Any]    						=offset if offset is not None else self.offset
   lowerCamelCase__:   Dict    						=do_normalize if do_normalize is not None else self.do_normalize
   lowerCamelCase__:   Optional[int]    						=image_mean if image_mean is not None else self.image_mean
   lowerCamelCase__:   List[Any]    						=image_std if image_std is not None else self.image_std

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

   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.")

   lowerCamelCase__:   str    						=make_batched(UpperCAmelCase_)

   lowerCamelCase__:   Any    						=[
       [
           self._preprocess_image(
               image=UpperCAmelCase_ ,				do_resize=UpperCAmelCase_ ,				size=UpperCAmelCase_ ,				resample=UpperCAmelCase_ ,				do_center_crop=UpperCAmelCase_ ,				crop_size=UpperCAmelCase_ ,				do_rescale=UpperCAmelCase_ ,				rescale_factor=UpperCAmelCase_ ,				offset=UpperCAmelCase_ ,				do_normalize=UpperCAmelCase_ ,				image_mean=UpperCAmelCase_ ,				image_std=UpperCAmelCase_ ,				data_format=UpperCAmelCase_ ,				)
           for img in video
       ]
       for video in videos
   ]

   lowerCamelCase__:   int    						={"pixel_values": videos}
   return BatchFeature(data=UpperCAmelCase_ ,				tensor_type=UpperCAmelCase_)

