
'''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,
    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,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, logging


if is_torch_available():
      import torch


lowercase     :							Any       						=     logging.get_logger(__name__)





class 					A							(				__snake_case		):
     __magic_name__          =						['''pixel_values''']





     def __init__(				self		,     SCREAMING_SNAKE_CASE = True		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = PILImageResampling.BILINEAR		,     SCREAMING_SNAKE_CASE = True		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = True		,     SCREAMING_SNAKE_CASE = 1 / 255		,     SCREAMING_SNAKE_CASE = True		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = None		,     **SCREAMING_SNAKE_CASE		,     )					->							None:






         """simple docstring"""






         super().__init__(**SCREAMING_SNAKE_CASE      )
         A			:  List[Any]   =		size if size is not None else {'''shortest_edge''': 256}
         A			:  Tuple   =		get_size_dict(SCREAMING_SNAKE_CASE		,     default_to_square=SCREAMING_SNAKE_CASE      )
         A			:  Optional[Any]   =		crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
         A			:  Any   =		get_size_dict(SCREAMING_SNAKE_CASE		,     param_name='''crop_size'''      )
         A			:  Tuple   =		do_resize
         A			:  str   =		size
         A			:  List[str]   =		resample
         A			:  List[str]   =		do_center_crop
         A			:  int   =		crop_size
         A			:  List[str]   =		do_rescale
         A			:  List[str]   =		rescale_factor
         A			:  Optional[Any]   =		do_normalize
         A			:  int   =		image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
         A			:  Union[str, Any]   =		image_std if image_std is not None else IMAGENET_STANDARD_STD





     def 							__lowerCAmelCase				(				self		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE = PILImageResampling.BICUBIC		,     SCREAMING_SNAKE_CASE = None		,     **SCREAMING_SNAKE_CASE		,     )					->							np.ndarray:






         """simple docstring"""






         A			:  Dict   =		get_size_dict(SCREAMING_SNAKE_CASE		,     default_to_square=SCREAMING_SNAKE_CASE      )
         if "shortest_edge" not in size:
             raise ValueError(F'The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}'      )
         A			:  List[str]   =		get_resize_output_image_size(SCREAMING_SNAKE_CASE		,     size=size['''shortest_edge''']		,     default_to_square=SCREAMING_SNAKE_CASE      )
         return resize(SCREAMING_SNAKE_CASE		,     size=SCREAMING_SNAKE_CASE		,     resample=SCREAMING_SNAKE_CASE		,     data_format=SCREAMING_SNAKE_CASE		,     **SCREAMING_SNAKE_CASE      )





     def 							__lowerCAmelCase				(				self		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE = None		,     **SCREAMING_SNAKE_CASE		,     )					->							np.ndarray:






         """simple docstring"""






         A			:  str   =		get_size_dict(SCREAMING_SNAKE_CASE      )
         if "height" not in size or "width" not in size:
             raise ValueError(F'The `size` parameter must contain the keys `height` and `width`. Got {size.keys()}'      )
         return center_crop(SCREAMING_SNAKE_CASE		,     size=(size['''height'''], size['''width'''])		,     data_format=SCREAMING_SNAKE_CASE		,     **SCREAMING_SNAKE_CASE      )





     def 							__lowerCAmelCase				(				self		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE = None		,     **SCREAMING_SNAKE_CASE      )					->							np.ndarray:






         """simple docstring"""






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





     def 							__lowerCAmelCase				(				self		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE = None		,     **SCREAMING_SNAKE_CASE		,     )					->							np.ndarray:






         """simple docstring"""






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





     def 							__lowerCAmelCase				(				self		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = None		,     SCREAMING_SNAKE_CASE = ChannelDimension.FIRST		,     **SCREAMING_SNAKE_CASE		,     )					->							Tuple:






         """simple docstring"""






         A			:  List[str]   =		do_resize if do_resize is not None else self.do_resize
         A			:  Dict   =		size if size is not None else self.size
         A			:  Optional[Any]   =		get_size_dict(SCREAMING_SNAKE_CASE		,     default_to_square=SCREAMING_SNAKE_CASE      )
         A			:  Dict   =		resample if resample is not None else self.resample
         A			:  Any   =		do_center_crop if do_center_crop is not None else self.do_center_crop
         A			:  int   =		crop_size if crop_size is not None else self.crop_size
         A			:  List[str]   =		get_size_dict(SCREAMING_SNAKE_CASE		,     param_name='''crop_size'''      )
         A			:  Tuple   =		do_rescale if do_rescale is not None else self.do_rescale
         A			:  Tuple   =		rescale_factor if rescale_factor is not None else self.rescale_factor
         A			:  Dict   =		do_normalize if do_normalize is not None else self.do_normalize
         A			:  Optional[Any]   =		image_mean if image_mean is not None else self.image_mean
         A			:  Any   =		image_std if image_std is not None else self.image_std

         A			:  List[Any]   =		make_list_of_images(SCREAMING_SNAKE_CASE      )

         if not valid_images(SCREAMING_SNAKE_CASE      ):
             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_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.'''      )

         # All transformations expect numpy arrays.
         A			:  Union[str, Any]   =		[to_numpy_array(SCREAMING_SNAKE_CASE      ) for image in images]

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

         if do_center_crop:
             A			:  Any   =		[self.center_crop(image=SCREAMING_SNAKE_CASE		,     size=SCREAMING_SNAKE_CASE      ) for image in images]

         if do_rescale:
             A			:  Dict   =		[self.rescale(image=SCREAMING_SNAKE_CASE		,     scale=SCREAMING_SNAKE_CASE      ) for image in images]

         if do_normalize:
             A			:  Optional[int]   =		[self.normalize(image=SCREAMING_SNAKE_CASE		,     mean=SCREAMING_SNAKE_CASE		,     std=SCREAMING_SNAKE_CASE      ) for image in images]

         A			:  Tuple   =		[to_channel_dimension_format(SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE      ) for image in images]

         A			:  Optional[Any]   =		{'''pixel_values''': images}
         return BatchFeature(data=SCREAMING_SNAKE_CASE		,     tensor_type=SCREAMING_SNAKE_CASE      )





     def 							__lowerCAmelCase				(				self		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE = None      )					->							Tuple:






         """simple docstring"""






         A			:  str   =		outputs.logits

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

             if is_torch_tensor(SCREAMING_SNAKE_CASE      ):
                 A			:  Optional[int]   =		target_sizes.numpy()

             A			:  Dict   =		[]

             for idx in range(len(SCREAMING_SNAKE_CASE      )      ):
                 A			:  Dict   =		torch.nn.functional.interpolate(
                     logits[idx].unsqueeze(dim=0      )		,     size=target_sizes[idx]		,     mode='''bilinear'''		,     align_corners=SCREAMING_SNAKE_CASE      )
                 A			:  List[Any]   =		resized_logits[0].argmax(dim=0      )
                 semantic_segmentation.append(SCREAMING_SNAKE_CASE      )
         else:
             A			:  List[Any]   =		logits.argmax(dim=1      )
             A			:  Any   =		[semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]      )]

         return semantic_segmentation






'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase     :							Tuple       						=     {
    'configuration_luke': ['LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LukeConfig'],
    'tokenization_luke': ['LukeTokenizer'],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase     :							int       						=     [
          'LUKE_PRETRAINED_MODEL_ARCHIVE_LIST',
          'LukeForEntityClassification',
          'LukeForEntityPairClassification',
          'LukeForEntitySpanClassification',
          'LukeForMultipleChoice',
          'LukeForQuestionAnswering',
          'LukeForSequenceClassification',
          'LukeForTokenClassification',
          'LukeForMaskedLM',
          'LukeModel',
          'LukePreTrainedModel',
      ]


if TYPE_CHECKING:
      from .configuration_luke import LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP, LukeConfig
      from .tokenization_luke import LukeTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_luke import (
                LUKE_PRETRAINED_MODEL_ARCHIVE_LIST,
                LukeForEntityClassification,
                LukeForEntityPairClassification,
                LukeForEntitySpanClassification,
                LukeForMaskedLM,
                LukeForMultipleChoice,
                LukeForQuestionAnswering,
                LukeForSequenceClassification,
                LukeForTokenClassification,
                LukeModel,
                LukePreTrainedModel,
            )

else:
      import sys

      lowercase     :							Dict       						=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




