





'''simple docstring'''






from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, 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_vision_available, logging


if is_vision_available():
      import PIL


A__       :     Optional[Any]          =logging.get_logger(__name__)




class 				UpperCAmelCase  (    __lowerCamelCase     ):
      _lowercase:    List[str]		  =     ['pixel_values']




      def __init__(    self    :				List[str]    ,    __snake_case    :				bool = True    ,    __snake_case    :				Dict[str, int] = None    ,    __snake_case    :				PILImageResampling = PIL.Image.NEAREST    ,    __snake_case    :				bool = False    ,    __snake_case    :				Dict[str, int] = None    ,    __snake_case    :				Union[int, float] = 1 / 2_55    ,    __snake_case    :				bool = False    ,    __snake_case    :				bool = True    ,    __snake_case    :				bool = True    ,    __snake_case    :				Optional[Union[float, List[float]]] = None    ,    __snake_case    :				Optional[Union[float, List[float]]] = None    ,    __snake_case    :				bool = True    ,    **__snake_case    :				Optional[Any]    ,    )       ->   None:
            super().__init__(**__snake_case						)
            _lowerCAmelCase							  =							size if size is not None else {"""height""": 3_46, """width""": 3_46}
            _lowerCAmelCase							  =							get_size_dict(__snake_case						)
            _lowerCAmelCase							  =							crop_size if crop_size is not None else {"""height""": 2_89, """width""": 2_89}
            _lowerCAmelCase							  =							get_size_dict(__snake_case    ,    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							  =							rescale_offset
            _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
            _lowerCAmelCase							  =							include_top




      def        lowercase__					(    self    :				List[Any]    ,    __snake_case    :				np.ndarray    ,    __snake_case    :				Dict[str, int]    ,    __snake_case    :				PILImageResampling = PIL.Image.NEAREST    ,    __snake_case    :				Optional[Union[str, ChannelDimension]] = None    ,    **__snake_case    :				int    ,    )       ->   np.ndarray:
            _lowerCAmelCase							  =							get_size_dict(__snake_case						)
            if "height" not in size or "width" not in size:
                  raise ValueError(f"The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"						)
            return resize(
                __snake_case    ,    size=(size["""height"""], size["""width"""])    ,    resample=__snake_case    ,    data_format=__snake_case    ,    **__snake_case						)




      def        lowercase__					(    self    :				int    ,    __snake_case    :				np.ndarray    ,    __snake_case    :				Dict[str, int]    ,    __snake_case    :				Optional[Union[str, ChannelDimension]] = None    ,    **__snake_case    :				Optional[Any]    ,    )       ->   np.ndarray:
            _lowerCAmelCase							  =							get_size_dict(__snake_case						)
            if "height" not in size or "width" not in size:
                  raise ValueError(f"The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"						)
            return center_crop(__snake_case    ,    size=(size["""height"""], size["""width"""])    ,    data_format=__snake_case    ,    **__snake_case						)




      def        lowercase__					(    self    :				Any    ,    __snake_case    :				np.ndarray    ,    __snake_case    :				Union[int, float]    ,    __snake_case    :				bool = True    ,    __snake_case    :				Optional[Union[str, ChannelDimension]] = None    ,    **__snake_case    :				Union[str, Any]    ,    )       ->   Optional[int]:






            if offset:
                  _lowerCAmelCase							  =							(image - 1_27.5) * scale
                  if data_format is not None:
                        _lowerCAmelCase							  =							to_channel_dimension_format(__snake_case    ,    __snake_case						)
                  _lowerCAmelCase							  =							rescaled_image.astype(np.floataa						)
            else:
                  _lowerCAmelCase							  =							rescale(__snake_case    ,    scale=__snake_case    ,    data_format=__snake_case    ,    **__snake_case						)
            return rescaled_image




      def        lowercase__					(    self    :				Union[str, 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    :				int    ,    )       ->   np.ndarray:
            return normalize(__snake_case    ,    mean=__snake_case    ,    std=__snake_case    ,    data_format=__snake_case    ,    **__snake_case						)




      def        lowercase__					(    self    :				Dict    ,    __snake_case    :				ImageInput    ,    __snake_case    :				bool = None    ,    __snake_case    :				Dict[str, int] = None    ,    __snake_case    :				Optional[int]=None    ,    __snake_case    :				bool = None    ,    __snake_case    :				Dict[str, int] = None    ,    __snake_case    :				bool = None    ,    __snake_case    :				float = None    ,    __snake_case    :				bool = None    ,    __snake_case    :				bool = None    ,    __snake_case    :				Optional[Union[float, List[float]]] = None    ,    __snake_case    :				Optional[Union[float, List[float]]] = None    ,    __snake_case    :				bool = None    ,    __snake_case    :				Optional[Union[str, TensorType]] = None    ,    __snake_case    :				ChannelDimension = ChannelDimension.FIRST    ,    **__snake_case    :				Dict    ,    )       ->   PIL.Image.Image:
            _lowerCAmelCase							  =							do_resize if do_resize is not None else self.do_resize
            _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							  =							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							  =							rescale_offset if rescale_offset is not None else self.rescale_offset
            _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							  =							include_top if include_top is not None else self.include_top

            _lowerCAmelCase							  =							size if size is not None else self.size
            _lowerCAmelCase							  =							get_size_dict(__snake_case						)
            _lowerCAmelCase							  =							crop_size if crop_size is not None else self.crop_size
            _lowerCAmelCase							  =							get_size_dict(__snake_case    ,    param_name="""crop_size"""						)

            _lowerCAmelCase							  =							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_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(__snake_case						) for image in images]

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

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

            if do_rescale:
                  _lowerCAmelCase							  =							[self.rescale(image=__snake_case    ,    scale=__snake_case    ,    offset=__snake_case						) for image in images]

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

            if include_top:
                  _lowerCAmelCase							  =							[self.normalize(image=__snake_case    ,    mean=[0, 0, 0]    ,    std=__snake_case						) for image in images]

            _lowerCAmelCase							  =							[to_channel_dimension_format(__snake_case    ,    __snake_case						) for image in images]

            _lowerCAmelCase							  =							{"""pixel_values""": images}
            return BatchFeature(data=__snake_case    ,    tensor_type=__snake_case						)













'''simple docstring'''






import os
import random
from pathlib import Path
from typing import List

import numpy as np
import torch
from torch.cuda.amp import GradScaler

from .utils import (
    MODEL_NAME,
    OPTIMIZER_NAME,
    RNG_STATE_NAME,
    SCALER_NAME,
    SCHEDULER_NAME,
    get_pretty_name,
    is_tpu_available,
    is_xpu_available,
    save,
)


if is_tpu_available(check_device=False):
      import torch_xla.core.xla_model as xm

from .logging import get_logger
from .state import PartialState


A__       :     Optional[Any]          =get_logger(__name__)
def      UpperCamelCase__   (	lowerCAmelCase							,			lowerCAmelCase							,			lowerCAmelCase							,			lowerCAmelCase							,			lowerCAmelCase							,			lowerCAmelCase = None							,			):





      """simple docstring"""


      for i, state in enumerate(lowerCAmelCase						):
            _lowerCAmelCase							  =							f"{MODEL_NAME}.bin" if i == 0 else f"{MODEL_NAME}_{i}.bin"
            _lowerCAmelCase							  =							os.path.join(lowerCAmelCase							,			lowerCAmelCase						)
            save(lowerCAmelCase							,			lowerCAmelCase						)
            logger.info(f"Model weights saved in {output_model_file}"						)
      # Optimizer states
      for i, opt in enumerate(lowerCAmelCase						):
            _lowerCAmelCase							  =							opt.state_dict()
            _lowerCAmelCase							  =							f"{OPTIMIZER_NAME}.bin" if i == 0 else f"{OPTIMIZER_NAME}_{i}.bin"
            _lowerCAmelCase							  =							os.path.join(lowerCAmelCase							,			lowerCAmelCase						)
            save(lowerCAmelCase							,			lowerCAmelCase						)
            logger.info(f"Optimizer state saved in {output_optimizer_file}"						)
      # Scheduler states
      for i, scheduler in enumerate(lowerCAmelCase						):
            _lowerCAmelCase							  =							scheduler.state_dict()
            _lowerCAmelCase							  =							f"{SCHEDULER_NAME}.bin" if i == 0 else f"{SCHEDULER_NAME}_{i}.bin"
            _lowerCAmelCase							  =							os.path.join(lowerCAmelCase							,			lowerCAmelCase						)
            save(lowerCAmelCase							,			lowerCAmelCase						)
            logger.info(f"Scheduler state saved in {output_scheduler_file}"						)
      # GradScaler state
      if scaler is not None:
            _lowerCAmelCase							  =							scaler.state_dict()
            _lowerCAmelCase							  =							os.path.join(lowerCAmelCase							,			lowerCAmelCase						)
            torch.save(lowerCAmelCase							,			lowerCAmelCase						)
            logger.info(f"Gradient scaler state saved in {output_scaler_file}"						)
      # Random number generator states
      _lowerCAmelCase							  =							{}
      _lowerCAmelCase							  =							f"{RNG_STATE_NAME}_{process_index}.pkl"
      _lowerCAmelCase							  =							random.getstate()
      _lowerCAmelCase							  =							np.random.get_state()
      _lowerCAmelCase							  =							torch.get_rng_state()
      if is_xpu_available():
            _lowerCAmelCase							  =							torch.xpu.get_rng_state_all()
      else:
            _lowerCAmelCase							  =							torch.cuda.get_rng_state_all()
      if is_tpu_available():
            _lowerCAmelCase							  =							xm.get_rng_state()
      _lowerCAmelCase							  =							os.path.join(lowerCAmelCase							,			lowerCAmelCase						)
      torch.save(lowerCAmelCase							,			lowerCAmelCase						)
      logger.info(f"Random states saved in {output_states_file}"						)
      return output_dir
def      UpperCamelCase__   (	lowerCAmelCase							,			lowerCAmelCase							,			lowerCAmelCase							,			lowerCAmelCase							,			lowerCAmelCase							,			lowerCAmelCase=None							,			lowerCAmelCase=None							,			**lowerCAmelCase							,			):





      """simple docstring"""


      if map_location not in [None, "cpu", "on_device"]:
            raise TypeError(
                """Unsupported optimizer map location passed, please choose one of `None`, `'cpu'`, or `'on_device'`"""						)
      if map_location is None:
            _lowerCAmelCase							  =							"""cpu"""
      elif map_location == "on_device":
            _lowerCAmelCase							  =							PartialState().device
      # Model states
      for i, model in enumerate(lowerCAmelCase						):
            _lowerCAmelCase							  =							f"{MODEL_NAME}.bin" if i == 0 else f"{MODEL_NAME}_{i}.bin"
            _lowerCAmelCase							  =							os.path.join(lowerCAmelCase							,			lowerCAmelCase						)
            models[i].load_state_dict(torch.load(lowerCAmelCase							,			map_location=lowerCAmelCase						)							,			**lowerCAmelCase						)
      logger.info("""All model weights loaded successfully"""						)

      # Optimizer states
      for i, opt in enumerate(lowerCAmelCase						):
            _lowerCAmelCase							  =							f"{OPTIMIZER_NAME}.bin" if i == 0 else f"{OPTIMIZER_NAME}_{i}.bin"
            _lowerCAmelCase							  =							os.path.join(lowerCAmelCase							,			lowerCAmelCase						)
            _lowerCAmelCase							  =							torch.load(lowerCAmelCase							,			map_location=lowerCAmelCase						)
            optimizers[i].load_state_dict(lowerCAmelCase						)
      logger.info("""All optimizer states loaded successfully"""						)

      # Scheduler states
      for i, scheduler in enumerate(lowerCAmelCase						):
            _lowerCAmelCase							  =							f"{SCHEDULER_NAME}.bin" if i == 0 else f"{SCHEDULER_NAME}_{i}.bin"
            _lowerCAmelCase							  =							os.path.join(lowerCAmelCase							,			lowerCAmelCase						)
            scheduler.load_state_dict(torch.load(lowerCAmelCase						)						)
      logger.info("""All scheduler states loaded successfully"""						)

      # GradScaler state
      if scaler is not None:
            _lowerCAmelCase							  =							os.path.join(lowerCAmelCase							,			lowerCAmelCase						)
            scaler.load_state_dict(torch.load(lowerCAmelCase						)						)
            logger.info("""GradScaler state loaded successfully"""						)

      # Random states
      try:
            _lowerCAmelCase							  =							torch.load(os.path.join(lowerCAmelCase							,			f"{RNG_STATE_NAME}_{process_index}.pkl"						)						)
            random.setstate(states["""random_state"""]						)
            np.random.set_state(states["""numpy_random_seed"""]						)
            torch.set_rng_state(states["""torch_manual_seed"""]						)
            if is_xpu_available():
                  torch.xpu.set_rng_state_all(states["""torch_xpu_manual_seed"""]						)
            else:
                  torch.cuda.set_rng_state_all(states["""torch_cuda_manual_seed"""]						)
            if is_tpu_available():
                  xm.set_rng_state(states["""xm_seed"""]						)
            logger.info("""All random states loaded successfully"""						)
      except Exception:
            logger.info("""Could not load random states"""						)
def      UpperCamelCase__   (	lowerCAmelCase							,			lowerCAmelCase							,			lowerCAmelCase = 0						):





      """simple docstring"""


      _lowerCAmelCase							  =							Path(lowerCAmelCase						) / f"custom_checkpoint_{index}.pkl"
      logger.info(f"Saving the state of {get_pretty_name(lowerCAmelCase						)} to {save_location}"						)
      torch.save(obj.state_dict()							,			lowerCAmelCase						)





def      UpperCamelCase__   (	lowerCAmelCase							,			lowerCAmelCase							,			lowerCAmelCase = 0						):





      """simple docstring"""


      _lowerCAmelCase							  =							f"{path}/custom_checkpoint_{index}.pkl"
      logger.info(f"Loading the state of {get_pretty_name(lowerCAmelCase						)} from {load_location}"						)
      obj.load_state_dict(torch.load(lowerCAmelCase							,			map_location="""cpu"""						)						)






