'''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     							=logging.get_logger(__name__)




class     a__      (   UpperCAmelCase__ ):
     lowerCamelCase  :     Tuple							=["pixel_values"]






     def __init__( self		:		Any  ,				a		:		bool = True  ,				a		:		Optional[Dict[str, int]] = None  ,				a		:		PILImageResampling = PILImageResampling.BILINEAR  ,				a		:		bool = True  ,				a		:		Dict[str, int] = None  ,				a		:		bool = True  ,				a		:		Union[int, float] = 1 / 2_55  ,				a		:		bool = True  ,				a		:		Optional[Union[float, List[float]]] = None  ,				a		:		Optional[Union[float, List[float]]] = None  ,				**a		:		Dict  ,				):





         """simple docstring"""



         super().__init__(**a    )
         __lowerCamelCase		=  size if size is not None else {'''shortest_edge''': 2_56}
         __lowerCamelCase		=  get_size_dict(a  ,				default_to_square=a    )
         __lowerCamelCase		=  crop_size if crop_size is not None else {'''height''': 2_24, '''width''': 2_24}
         __lowerCamelCase		=  get_size_dict(a  ,				param_name='''crop_size'''    )
         __lowerCamelCase		=  do_resize
         __lowerCamelCase		=  size
         __lowerCamelCase		=  resample
         __lowerCamelCase		=  do_center_crop
         __lowerCamelCase		=  crop_size
         __lowerCamelCase		=  do_rescale
         __lowerCamelCase		=  rescale_factor
         __lowerCamelCase		=  do_normalize
         __lowerCamelCase		=  image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
         __lowerCamelCase		=  image_std if image_std is not None else IMAGENET_STANDARD_STD






     def    SCREAMING_SNAKE_CASE__   ( self		:		Tuple  ,				a		:		np.ndarray  ,				a		:		Dict[str, int]  ,				a		:		PILImageResampling = PILImageResampling.BICUBIC  ,				a		:		Optional[Union[str, ChannelDimension]] = None  ,				**a		:		Dict  ,				):





         """simple docstring"""



         __lowerCamelCase		=  get_size_dict(a  ,				default_to_square=a    )
         if "shortest_edge" not in size:
             raise ValueError(f"""The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}"""    )
         __lowerCamelCase		=  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    SCREAMING_SNAKE_CASE__   ( self		:		Union[str, Any]  ,				a		:		np.ndarray  ,				a		:		Dict[str, int]  ,				a		:		Optional[Union[str, ChannelDimension]] = None  ,				**a		:		Dict  ,				):





         """simple docstring"""



         __lowerCamelCase		=  get_size_dict(a    )
         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(a  ,				size=(size['''height'''], size['''width'''])  ,				data_format=a  ,				**a    )






     def    SCREAMING_SNAKE_CASE__   ( self		:		Any  ,				a		:		np.ndarray  ,				a		:		float  ,				a		:		Optional[Union[str, ChannelDimension]] = None  ,				**a		:		Optional[int]    ):





         """simple docstring"""



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






     def    SCREAMING_SNAKE_CASE__   ( self		:		Union[str, Any]  ,				a		:		np.ndarray  ,				a		:		Union[float, List[float]]  ,				a		:		Union[float, List[float]]  ,				a		:		Optional[Union[str, ChannelDimension]] = None  ,				**a		:		Optional[Any]  ,				):





         """simple docstring"""



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






     def    SCREAMING_SNAKE_CASE__   ( self		:		Any  ,				a		:		ImageInput  ,				a		:		Optional[bool] = None  ,				a		:		Dict[str, int] = None  ,				a		:		PILImageResampling = None  ,				a		:		bool = None  ,				a		:		Dict[str, int] = None  ,				a		:		Optional[bool] = None  ,				a		:		Optional[float] = None  ,				a		:		Optional[bool] = None  ,				a		:		Optional[Union[float, List[float]]] = None  ,				a		:		Optional[Union[float, List[float]]] = None  ,				a		:		Optional[Union[str, TensorType]] = None  ,				a		:		Union[str, ChannelDimension] = ChannelDimension.FIRST  ,				**a		:		List[Any]  ,				):





         """simple docstring"""



         __lowerCamelCase		=  do_resize if do_resize is not None else self.do_resize
         __lowerCamelCase		=  size if size is not None else self.size
         __lowerCamelCase		=  get_size_dict(a  ,				default_to_square=a    )
         __lowerCamelCase		=  resample if resample is not None else self.resample
         __lowerCamelCase		=  do_center_crop if do_center_crop is not None else self.do_center_crop
         __lowerCamelCase		=  crop_size if crop_size is not None else self.crop_size
         __lowerCamelCase		=  get_size_dict(a  ,				param_name='''crop_size'''    )
         __lowerCamelCase		=  do_rescale if do_rescale is not None else self.do_rescale
         __lowerCamelCase		=  rescale_factor if rescale_factor is not None else self.rescale_factor
         __lowerCamelCase		=  do_normalize if do_normalize is not None else self.do_normalize
         __lowerCamelCase		=  image_mean if image_mean is not None else self.image_mean
         __lowerCamelCase		=  image_std if image_std is not None else self.image_std

         __lowerCamelCase		=  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_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.
         __lowerCamelCase		=  [to_numpy_array(a    ) for image in images]

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

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

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

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

         __lowerCamelCase		=  [to_channel_dimension_format(a  ,				a    ) for image in images]

         __lowerCamelCase		=  {'''pixel_values''': images}
         return BatchFeature(data=a  ,				tensor_type=a    )






     def    SCREAMING_SNAKE_CASE__   ( self		:		Union[str, Any]  ,				a		:		Tuple  ,				a		:		List[Tuple] = None    ):





         """simple docstring"""



         __lowerCamelCase		=  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    ):
                 __lowerCamelCase		=  target_sizes.numpy()

             __lowerCamelCase		=  []

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


A_							: Optional[Any]						 =	{
    """configuration_llama""": ["""LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """LlamaConfig"""],
}

try:
   if not is_sentencepiece_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_							: List[str]						 =	["""LlamaTokenizer"""]

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_							: Dict						 =	["""LlamaTokenizerFast"""]

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A_							: Optional[int]						 =	[
       """LlamaForCausalLM""",
       """LlamaModel""",
       """LlamaPreTrainedModel""",
       """LlamaForSequenceClassification""",
   ]


if TYPE_CHECKING:
   from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig

   try:
      if not is_sentencepiece_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_llama import LlamaTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_llama_fast import LlamaTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel


else:
   import sys

   A_							: Any						 =	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



