





'''simple docstring'''




import math
from typing import Dict, Iterable, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    is_torch_available,
    is_torch_tensor,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_torch_available():
  import torch

if is_vision_available():
  import PIL


__SCREAMING_SNAKE_CASE     :int       =				logging.get_logger(__name__)
def 	UpperCAmelCase_							(					__lowercase							:      np.ndarray			,     __lowercase							:      Union[int, Iterable[int]]			,     __lowercase							:      bool			,     __lowercase							:      int       )		->       Tuple[int, int]:


     '''simple docstring'''



     def constraint_to_multiple_of(__lowercase							:      Union[str, Any]			,     __lowercase							:      List[str]			,     __lowercase							:      List[str]=0			,     __lowercase							:      Any=None       ):
          _UpperCAmelCase     							=   round(val / multiple       ) * multiple

          if max_val is not None and x > max_val:
               _UpperCAmelCase     							=   math.floor(val / multiple       ) * multiple

          if x < min_val:
               _UpperCAmelCase     							=   math.ceil(val / multiple       ) * multiple

          return x

     _UpperCAmelCase     							=   (output_size, output_size) if isinstance(__lowercase			,     __lowercase       ) else output_size

     _UpperCAmelCase							,  _UpperCAmelCase     							=   get_image_size(__lowercase       )
     _UpperCAmelCase							,  _UpperCAmelCase     							=   output_size

     # determine new height and width
     _UpperCAmelCase     							=   output_height / input_height
     _UpperCAmelCase     							=   output_width / input_width

     if keep_aspect_ratio:
          # scale as little as possible
          if abs(1 - scale_width       ) < abs(1 - scale_height       ):
               # fit width
               _UpperCAmelCase     							=   scale_width
          else:
               # fit height
               _UpperCAmelCase     							=   scale_height

     _UpperCAmelCase     							=   constraint_to_multiple_of(scale_height * input_height			,     multiple=__lowercase       )
     _UpperCAmelCase     							=   constraint_to_multiple_of(scale_width * input_width			,     multiple=__lowercase       )

     return (new_height, new_width)







class   A_	(  lowerCAmelCase_			):
 _lowerCamelCase  : List[Any]           =							["""pixel_values"""]




 def __init__(					self       :    int	,			snake_case_       :    bool = True	,			snake_case_       :    Dict[str, int] = None	,			snake_case_       :    PILImageResampling = PILImageResampling.BILINEAR	,			snake_case_       :    bool = False	,			snake_case_       :    int = 1	,			snake_case_       :    bool = True	,			snake_case_       :    Union[int, float] = 1 / 2_5_5	,			snake_case_       :    bool = True	,			snake_case_       :    Optional[Union[float, List[float]]] = None	,			snake_case_       :    Optional[Union[float, List[float]]] = None	,			**snake_case_       :    Dict	,			):
      super().__init__(**snake_case_    )
      _UpperCAmelCase     							=   size if size is not None else {"height": 3_8_4, "width": 3_8_4}
      _UpperCAmelCase     							=   get_size_dict(snake_case_    )
      _UpperCAmelCase     							=   do_resize
      _UpperCAmelCase     							=   size
      _UpperCAmelCase     							=   keep_aspect_ratio
      _UpperCAmelCase     							=   ensure_multiple_of
      _UpperCAmelCase     							=   resample
      _UpperCAmelCase     							=   do_rescale
      _UpperCAmelCase     							=   rescale_factor
      _UpperCAmelCase     							=   do_normalize
      _UpperCAmelCase     							=   image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
      _UpperCAmelCase     							=   image_std if image_std is not None else IMAGENET_STANDARD_STD




 def      lowercase	(					self       :    Any	,			snake_case_       :    np.ndarray	,			snake_case_       :    Dict[str, int]	,			snake_case_       :    bool = False	,			snake_case_       :    int = 1	,			snake_case_       :    PILImageResampling = PILImageResampling.BICUBIC	,			snake_case_       :    Optional[Union[str, ChannelDimension]] = None	,			**snake_case_       :    int	,			):
      _UpperCAmelCase     							=   get_size_dict(snake_case_    )
      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()}'    )
      _UpperCAmelCase     							=   get_resize_output_image_size(
          snake_case_	,			output_size=(size["height"], size["width"])	,			keep_aspect_ratio=snake_case_	,			multiple=snake_case_	,			)
      return resize(snake_case_	,			size=snake_case_	,			resample=snake_case_	,			data_format=snake_case_	,			**snake_case_    )




 def      lowercase	(					self       :    List[str]	,			snake_case_       :    np.ndarray	,			snake_case_       :    Union[int, float]	,			snake_case_       :    Optional[Union[str, ChannelDimension]] = None	,			**snake_case_       :    Tuple	,			):
      return rescale(snake_case_	,			scale=snake_case_	,			data_format=snake_case_	,			**snake_case_    )




 def      lowercase	(					self       :    List[Any]	,			snake_case_       :    np.ndarray	,			snake_case_       :    Union[float, List[float]]	,			snake_case_       :    Union[float, List[float]]	,			snake_case_       :    Optional[Union[str, ChannelDimension]] = None	,			**snake_case_       :    List[str]	,			):
      return normalize(snake_case_	,			mean=snake_case_	,			std=snake_case_	,			data_format=snake_case_	,			**snake_case_    )




 def      lowercase	(					self       :    Union[str, Any]	,			snake_case_       :    ImageInput	,			snake_case_       :    bool = None	,			snake_case_       :    int = None	,			snake_case_       :    bool = None	,			snake_case_       :    int = None	,			snake_case_       :    PILImageResampling = None	,			snake_case_       :    bool = None	,			snake_case_       :    float = None	,			snake_case_       :    bool = None	,			snake_case_       :    Optional[Union[float, List[float]]] = None	,			snake_case_       :    Optional[Union[float, List[float]]] = None	,			snake_case_       :    Optional[Union[str, TensorType]] = None	,			snake_case_       :    ChannelDimension = ChannelDimension.FIRST	,			**snake_case_       :    List[str]	,			):
      _UpperCAmelCase     							=   do_resize if do_resize is not None else self.do_resize
      _UpperCAmelCase     							=   size if size is not None else self.size
      _UpperCAmelCase     							=   get_size_dict(snake_case_    )
      _UpperCAmelCase     							=   keep_aspect_ratio if keep_aspect_ratio is not None else self.keep_aspect_ratio
      _UpperCAmelCase     							=   ensure_multiple_of if ensure_multiple_of is not None else self.ensure_multiple_of
      _UpperCAmelCase     							=   resample if resample is not None else self.resample
      _UpperCAmelCase     							=   do_rescale if do_rescale is not None else self.do_rescale
      _UpperCAmelCase     							=   rescale_factor if rescale_factor is not None else self.rescale_factor
      _UpperCAmelCase     							=   do_normalize if do_normalize is not None else self.do_normalize
      _UpperCAmelCase     							=   image_mean if image_mean is not None else self.image_mean
      _UpperCAmelCase     							=   image_std if image_std is not None else self.image_std

      _UpperCAmelCase     							=   make_list_of_images(snake_case_    )

      if not valid_images(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 or resample is None:
           raise ValueError("Size and resample 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_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.
      _UpperCAmelCase     							=   [to_numpy_array(snake_case_    ) for image in images]

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

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

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

      _UpperCAmelCase     							=   [to_channel_dimension_format(snake_case_	,			snake_case_    ) for image in images]

      _UpperCAmelCase     							=   {"pixel_values": images}
      return BatchFeature(data=snake_case_	,			tensor_type=snake_case_    )




 def      lowercase	(					self       :    Optional[int]	,			snake_case_       :    Any	,			snake_case_       :    List[Tuple] = None    ):
      _UpperCAmelCase     							=   outputs.logits

      # Resize logits and compute semantic segmentation maps
      if target_sizes is not None:
           if len(snake_case_    ) != len(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(snake_case_    ):
                _UpperCAmelCase     							=   target_sizes.numpy()

           _UpperCAmelCase     							=   []

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

      return semantic_segmentation











'''simple docstring'''




from ..utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_scipy_available,
    is_torch_available,
    is_torchsde_available,
)


try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ..utils.dummy_pt_objects import *  # noqa F403
else:
  from .scheduling_consistency_models import CMStochasticIterativeScheduler
  from .scheduling_ddim import DDIMScheduler
  from .scheduling_ddim_inverse import DDIMInverseScheduler
  from .scheduling_ddim_parallel import DDIMParallelScheduler
  from .scheduling_ddpm import DDPMScheduler
  from .scheduling_ddpm_parallel import DDPMParallelScheduler
  from .scheduling_deis_multistep import DEISMultistepScheduler
  from .scheduling_dpmsolver_multistep import DPMSolverMultistepScheduler
  from .scheduling_dpmsolver_multistep_inverse import DPMSolverMultistepInverseScheduler
  from .scheduling_dpmsolver_singlestep import DPMSolverSinglestepScheduler
  from .scheduling_euler_ancestral_discrete import EulerAncestralDiscreteScheduler
  from .scheduling_euler_discrete import EulerDiscreteScheduler
  from .scheduling_heun_discrete import HeunDiscreteScheduler
  from .scheduling_ipndm import IPNDMScheduler
  from .scheduling_k_dpm_2_ancestral_discrete import KDPMaAncestralDiscreteScheduler
  from .scheduling_k_dpm_2_discrete import KDPMaDiscreteScheduler
  from .scheduling_karras_ve import KarrasVeScheduler
  from .scheduling_pndm import PNDMScheduler
  from .scheduling_repaint import RePaintScheduler
  from .scheduling_sde_ve import ScoreSdeVeScheduler
  from .scheduling_sde_vp import ScoreSdeVpScheduler
  from .scheduling_unclip import UnCLIPScheduler
  from .scheduling_unipc_multistep import UniPCMultistepScheduler
  from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin
  from .scheduling_vq_diffusion import VQDiffusionScheduler

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ..utils.dummy_flax_objects import *  # noqa F403
else:
  from .scheduling_ddim_flax import FlaxDDIMScheduler
  from .scheduling_ddpm_flax import FlaxDDPMScheduler
  from .scheduling_dpmsolver_multistep_flax import FlaxDPMSolverMultistepScheduler
  from .scheduling_karras_ve_flax import FlaxKarrasVeScheduler
  from .scheduling_lms_discrete_flax import FlaxLMSDiscreteScheduler
  from .scheduling_pndm_flax import FlaxPNDMScheduler
  from .scheduling_sde_ve_flax import FlaxScoreSdeVeScheduler
  from .scheduling_utils_flax import (
      FlaxKarrasDiffusionSchedulers,
      FlaxSchedulerMixin,
      FlaxSchedulerOutput,
      broadcast_to_shape_from_left,
  )


try:
  if not (is_torch_available() and is_scipy_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ..utils.dummy_torch_and_scipy_objects import *  # noqa F403
else:
  from .scheduling_lms_discrete import LMSDiscreteScheduler

try:
  if not (is_torch_available() and is_torchsde_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ..utils.dummy_torch_and_torchsde_objects import *  # noqa F403
else:
  from .scheduling_dpmsolver_sde import DPMSolverSDEScheduler




