




'''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


UpperCamelCase_		:     Union[str, Any]          =		logging.get_logger(__name__)

class   _a							(		__lowerCAmelCase				):
     SCREAMING_SNAKE_CASE_				:       Optional[int]       							=		["""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:
          super().__init__(**_SCREAMING_SNAKE_CASE       )
          _snake_case				= size if size is not None else {"shortest_edge": 256}
          _snake_case				= get_size_dict(_SCREAMING_SNAKE_CASE   ,default_to_square=_SCREAMING_SNAKE_CASE       )
          _snake_case				= crop_size if crop_size is not None else {"height": 224, "width": 224}
          _snake_case				= get_size_dict(_SCREAMING_SNAKE_CASE   ,param_name="crop_size"       )
          _snake_case				= do_resize
          _snake_case				= size
          _snake_case				= resample
          _snake_case				= do_center_crop
          _snake_case				= crop_size
          _snake_case				= do_rescale
          _snake_case				= rescale_factor
          _snake_case				= do_normalize
          _snake_case				= image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
          _snake_case				= image_std if image_std is not None else IMAGENET_STANDARD_STD






     def 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE = PILImageResampling.BICUBIC   ,_SCREAMING_SNAKE_CASE = None   ,**_SCREAMING_SNAKE_CASE   ,)				->     np.ndarray:
          _snake_case				= 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()}"""       )
          _snake_case				= 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 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE = None   ,**_SCREAMING_SNAKE_CASE   ,)				->     np.ndarray:
          _snake_case				= 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 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE = None   ,**_SCREAMING_SNAKE_CASE       )				->     np.ndarray:
          return rescale(_SCREAMING_SNAKE_CASE   ,scale=_SCREAMING_SNAKE_CASE   ,data_format=_SCREAMING_SNAKE_CASE   ,**_SCREAMING_SNAKE_CASE       )






     def 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE = None   ,**_SCREAMING_SNAKE_CASE   ,)				->     np.ndarray:
          return normalize(_SCREAMING_SNAKE_CASE   ,mean=_SCREAMING_SNAKE_CASE   ,std=_SCREAMING_SNAKE_CASE   ,data_format=_SCREAMING_SNAKE_CASE   ,**_SCREAMING_SNAKE_CASE       )






     def 							_lowercase      (					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   ,)				->     Optional[Any]:
          _snake_case				= do_resize if do_resize is not None else self.do_resize
          _snake_case				= size if size is not None else self.size
          _snake_case				= get_size_dict(_SCREAMING_SNAKE_CASE   ,default_to_square=_SCREAMING_SNAKE_CASE       )
          _snake_case				= resample if resample is not None else self.resample
          _snake_case				= do_center_crop if do_center_crop is not None else self.do_center_crop
          _snake_case				= crop_size if crop_size is not None else self.crop_size
          _snake_case				= get_size_dict(_SCREAMING_SNAKE_CASE   ,param_name="crop_size"       )
          _snake_case				= do_rescale if do_rescale is not None else self.do_rescale
          _snake_case				= rescale_factor if rescale_factor is not None else self.rescale_factor
          _snake_case				= do_normalize if do_normalize is not None else self.do_normalize
          _snake_case				= image_mean if image_mean is not None else self.image_mean
          _snake_case				= image_std if image_std is not None else self.image_std

          _snake_case				= 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.
          _snake_case				= [to_numpy_array(_SCREAMING_SNAKE_CASE       ) for image in images]

          if do_resize:
               _snake_case				= [self.resize(image=_SCREAMING_SNAKE_CASE   ,size=_SCREAMING_SNAKE_CASE   ,resample=_SCREAMING_SNAKE_CASE       ) for image in images]

          if do_center_crop:
               _snake_case				= [self.center_crop(image=_SCREAMING_SNAKE_CASE   ,size=_SCREAMING_SNAKE_CASE       ) for image in images]

          if do_rescale:
               _snake_case				= [self.rescale(image=_SCREAMING_SNAKE_CASE   ,scale=_SCREAMING_SNAKE_CASE       ) for image in images]

          if do_normalize:
               _snake_case				= [self.normalize(image=_SCREAMING_SNAKE_CASE   ,mean=_SCREAMING_SNAKE_CASE   ,std=_SCREAMING_SNAKE_CASE       ) for image in images]

          _snake_case				= [to_channel_dimension_format(_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       ) for image in images]

          _snake_case				= {"pixel_values": images}
          return BatchFeature(data=_SCREAMING_SNAKE_CASE   ,tensor_type=_SCREAMING_SNAKE_CASE       )






     def 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE = None       )				->     Optional[Any]:
          _snake_case				= 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       ):
                    _snake_case				= target_sizes.numpy()

               _snake_case				= []

               for idx in range(len(_SCREAMING_SNAKE_CASE       )       ):
                    _snake_case				= torch.nn.functional.interpolate(
                        logits[idx].unsqueeze(dim=0       )   ,size=target_sizes[idx]   ,mode="bilinear"   ,align_corners=_SCREAMING_SNAKE_CASE       )
                    _snake_case				= resized_logits[0].argmax(dim=0       )
                    semantic_segmentation.append(_SCREAMING_SNAKE_CASE       )
          else:
               _snake_case				= logits.argmax(dim=1       )
               _snake_case				= [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


UpperCamelCase_		:     List[Any]          =		{
    '''configuration_git''': ['''GIT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GitConfig''', '''GitVisionConfig'''],
    '''processing_git''': ['''GitProcessor'''],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCamelCase_		:     Optional[Any]          =		[
       '''GIT_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''GitForCausalLM''',
       '''GitModel''',
       '''GitPreTrainedModel''',
       '''GitVisionModel''',
   ]

if TYPE_CHECKING:
   from .configuration_git import GIT_PRETRAINED_CONFIG_ARCHIVE_MAP, GitConfig, GitVisionConfig
   from .processing_git import GitProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_git import (
          GIT_PRETRAINED_MODEL_ARCHIVE_LIST,
          GitForCausalLM,
          GitModel,
          GitPreTrainedModel,
          GitVisionModel,
      )

else:
   import sys

   UpperCamelCase_		:     List[Any]          =		_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


