




from typing import List, Optional, Union

import numpy as np
import tensorflow as tf

from .utils import logging


snake_case_ : List[Any]    		=       logging.get_logger(__name__)


def    A						(__A   :    Union[tf.Tensor, np.ndarray]       )   ->      List[int]:







     """simple docstring"""


     if isinstance(__A   ,				np.ndarray       ):
          return list(tensor.shape       )

     UpperCAmelCase_          =							tf.shape(__A       )

     if tensor.shape == tf.TensorShape(__A       ):
          return dynamic

     UpperCAmelCase_          =							tensor.shape.as_list()

     return [dynamic[i] if s is None else s for i, s in enumerate(__A       )]


def    A						(__A   :    tf.Tensor   ,				__A   :    Optional[int] = None   ,				__A   :    Optional[str] = None       )   ->      tf.Tensor:







     """simple docstring"""


     return tf.nn.softmax(logits=logits + 1E-9   ,				axis=__A   ,				name=__A       )


def    A						(__A   :    Union[str, Any]   ,				__A   :    Optional[int]   ,				__A   :    str   ,				__A   :    Optional[int]=1E-5   ,				__A   :    int=-1       )   ->      Any:







     """simple docstring"""


     if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(__A   ,				__A       ):
          raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.'''       )

     # Get mean and variance on the axis to be normalized
     UpperCAmelCase_     ,       UpperCAmelCase_          =							tf.nn.moments(__A   ,				axes=[axis]   ,				keepdims=__A       )

     if axis != -1:
          # Reshape scale and weight to have the same rank as inputs, but with 1 dimensions
          # on every dimension except axis
          UpperCAmelCase_          =							[1] * inputs.shape.rank
          UpperCAmelCase_          =							shape_list(__A       )[axis]
          UpperCAmelCase_          =							tf.reshape(__A   ,				__A       )
          UpperCAmelCase_          =							tf.reshape(__A   ,				__A       )

     # Compute layer normalization using the batch_normalization
     # function.
     UpperCAmelCase_          =							tf.nn.batch_normalization(
         __A   ,				__A   ,				__A   ,				offset=__A   ,				scale=__A   ,				variance_epsilon=__A   ,				)
     return outputs


def    A						(__A   :    Any   ,				__A   :    List[Any]=0   ,				__A   :    Tuple=-1       )   ->      Optional[Any]:







     """simple docstring"""


     if end_dim < 0:
          end_dim += input.shape.rank
     if start_dim < 0:
          start_dim += input.shape.rank

     if start_dim == end_dim:
          return input

     UpperCAmelCase_          =							tf.shape(__A       )
     UpperCAmelCase_          =							tf.math.reduce_prod(in_shape[start_dim : end_dim + 1]       )
     UpperCAmelCase_          =							tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]]   ,				axis=0       )
     return tf.reshape(__A   ,				__A       )


def    A						(__A   :    tf.Tensor       )   ->      tf.Tensor:







     """simple docstring"""


     if not isinstance(__A   ,				tf.Tensor       ):
          UpperCAmelCase_          =							tf.convert_to_tensor(__A       )  # Catches stray NumPy inputs
     if encoder_attention_mask.shape.rank == 3:
          UpperCAmelCase_          =							encoder_attention_mask[:, None, :, :]
     if encoder_attention_mask.shape.rank == 2:
          UpperCAmelCase_          =							encoder_attention_mask[:, None, None, :]
     # T5 has a mask that can compare sequence ids, we can simulate this here with this transposition
     # Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow
     # /transformer/transformer_layers.py#L270
     # encoder_extended_attention_mask = (encoder_extended_attention_mask ==
     # encoder_extended_attention_mask.transpose(-1, -2))
     UpperCAmelCase_          =							(
         tf.cast(1   ,				encoder_attention_mask.dtype       ) - encoder_extended_attention_mask
     ) * encoder_extended_attention_mask.dtype.min

     return encoder_extended_attention_mask


def    A						(__A   :    tf.Tensor   ,				__A   :    int   ,				__A   :    str = "input_ids"       )   ->      None:







     """simple docstring"""


     tf.debugging.assert_less(
         __A   ,				tf.cast(__A   ,				dtype=tensor.dtype       )   ,				message=(
             F"""The maximum value of {tensor_name} ({tf.math.reduce_max(__A       )}) must be smaller than the embedding """
             F"""layer's input dimension ({embed_dim}). The likely cause is some problem at tokenization time."""
         )   ,				)


def    A						(__A   :    Tuple   ,				__A   :    Dict   ,				__A   :    List[Any]       )   ->      List[Any]:







     """simple docstring"""


     UpperCAmelCase_          =							64512
     # Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT`
     # because in that case even chunking the array would not make the saving
     # possible.
     UpperCAmelCase_          =							[x for x in data if len(__A       ) > HDF5_OBJECT_HEADER_LIMIT]

     # Expecting this to never be true.
     if bad_attributes:
          raise RuntimeError(
              '''The following attributes cannot be saved to HDF5 file because '''
              F"""they are larger than {HDF5_OBJECT_HEADER_LIMIT} """
              F"""bytes: {bad_attributes}"""       )

     UpperCAmelCase_          =							np.asarray(__A       )

     UpperCAmelCase_          =							1
     UpperCAmelCase_          =							np.array_split(__A   ,				__A       )

     # This will never loop forever thanks to the test above.
     while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data       ):
          num_chunks += 1
          UpperCAmelCase_          =							np.array_split(__A   ,				__A       )

     if num_chunks > 1:
          for chunk_id, chunk_data in enumerate(__A       ):
               UpperCAmelCase_          =							chunk_data
     else:
          UpperCAmelCase_          =							data


def    A						(__A   :    List[Any]   ,				__A   :    Any       )   ->      int:







     """simple docstring"""


     if name in group.attrs:
          UpperCAmelCase_          =							[n.decode('''utf8'''       ) if hasattr(__A   ,				'''decode'''       ) else n for n in group.attrs[name]]
     else:
          UpperCAmelCase_          =							[]
          UpperCAmelCase_          =							0
          while "%s%d" % (name, chunk_id) in group.attrs:
               data.extend(
                   [n.decode('''utf8'''       ) if hasattr(__A   ,				'''decode'''       ) else n for n in group.attrs['''%s%d''' % (name, chunk_id)]]       )
               chunk_id += 1
     return data


def    A						(__A   :    List[Any]       )   ->      Any:







     """simple docstring"""


     def _expand_single_ad_tensor(__A   :    Optional[int]       ):
          if isinstance(__A   ,				tf.Tensor       ) and t.shape.rank == 1:
               return tf.expand_dims(__A   ,				axis=-1       )
          return t

     return tf.nest.map_structure(_expand_single_ad_tensor   ,				__A       )








"""simple docstring"""




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


_A			:       List[Any]   		=       logging.get_logger(__name__)

class 		a__						(      a_						):
   __lowerCAmelCase            =				["""pixel_values"""]
   def __init__(			self	,    _a = True	,    _a = None	,    _a = PILImageResampling.BILINEAR	,    _a = True	,    _a = 1 / 255	,    _a = True	,    _a = None	,    _a = True	,    **_a	,    ):
          super().__init__(**_a				)
          lowercase    :				Optional[Any]       		=							size if size is not None else {"shortest_edge": 224}
          lowercase    :				List[Any]       		=							get_size_dict(_a	,    default_to_square=_a				)
          lowercase    :				str       		=							crop_size if crop_size is not None else {"height": 256, "width": 256}
          lowercase    :				List[str]       		=							get_size_dict(_a	,    param_name="crop_size"				)

          lowercase    :				int       		=							do_resize
          lowercase    :				Optional[int]       		=							size
          lowercase    :				str       		=							resample
          lowercase    :				List[Any]       		=							do_rescale
          lowercase    :				Union[str, Any]       		=							rescale_factor
          lowercase    :				Optional[int]       		=							do_center_crop
          lowercase    :				Union[str, Any]       		=							crop_size
          lowercase    :				Optional[Any]       		=							do_flip_channel_order
   def 			__magic_name__			(			self	,    _a	,    _a	,    _a = PIL.Image.BILINEAR	,    _a = None	,    **_a	,    ):
          lowercase    :				List[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()}"""				)
          lowercase    :				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	,    _a	,    _a	,    _a = None	,    **_a	,    ):
          lowercase    :				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	,    _a	,    _a	,    _a = None	,    **_a	,    ):
          return rescale(_a	,    scale=_a	,    data_format=_a	,    **_a				)
   def 			__magic_name__			(			self	,    _a	,    _a = None				):
          return flip_channel_order(_a	,    data_format=_a				)
   def 			__magic_name__			(			self	,    _a	,    _a = None	,    _a = None	,    _a = None	,    _a = None	,    _a = None	,    _a = None	,    _a = None	,    _a = None	,    _a = None	,    _a = ChannelDimension.FIRST	,    **_a	,    ):
          lowercase    :				Optional[Any]       		=							do_resize if do_resize is not None else self.do_resize
          lowercase    :				Tuple       		=							resample if resample is not None else self.resample
          lowercase    :				List[str]       		=							do_rescale if do_rescale is not None else self.do_rescale
          lowercase    :				List[Any]       		=							rescale_factor if rescale_factor is not None else self.rescale_factor
          lowercase    :				Union[str, Any]       		=							do_center_crop if do_center_crop is not None else self.do_center_crop
          lowercase    :				Optional[int]       		=							(
              do_flip_channel_order if do_flip_channel_order is not None else self.do_flip_channel_order
          )

          lowercase    :				str       		=							size if size is not None else self.size
          lowercase    :				Any       		=							get_size_dict(_a	,    default_to_square=_a				)
          lowercase    :				int       		=							crop_size if crop_size is not None else self.crop_size
          lowercase    :				Any       		=							get_size_dict(_a	,    param_name="crop_size"				)

          lowercase    :				int       		=							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.
          lowercase    :				Any       		=							[to_numpy_array(_a				) for image in images]

          if do_resize:
                 lowercase    :				Optional[int]       		=							[self.resize(image=_a	,    size=_a	,    resample=_a				) for image in images]

          if do_center_crop:
                 lowercase    :				str       		=							[self.center_crop(image=_a	,    size=_a				) for image in images]

          if do_rescale:
                 lowercase    :				Union[str, 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:
                 lowercase    :				int       		=							[self.flip_channel_order(image=_a				) for image in images]

          lowercase    :				int       		=							[to_channel_dimension_format(_a	,    _a				) for image in images]

          lowercase    :				Optional[Any]       		=							{"pixel_values": images}
          return BatchFeature(data=_a	,    tensor_type=_a				)

   def 			__magic_name__			(			self	,    _a	,    _a = None				):
          lowercase    :				Optional[int]       		=							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				):
                        lowercase    :				Tuple       		=							target_sizes.numpy()

                 lowercase    :				List[Any]       		=							[]

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

          return semantic_segmentation


