





'''simple docstring'''



import os
import sys
import tempfile

import torch

from .state import AcceleratorState
from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment




def 				snake_case_      (		SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__=()					,	SCREAMING_SNAKE_CASE__=None					,	SCREAMING_SNAKE_CASE__="no"					,	SCREAMING_SNAKE_CASE__="29500"       ):







  '''simple docstring'''



  _snake_case     		=				False
  _snake_case     		=				False
  if any(key.startswith("KAGGLE"       ) for key in os.environ.keys()       ):
    _snake_case     		=				True
  elif "IPython" in sys.modules:
    _snake_case     		=				"google.colab" in str(sys.modules["IPython"].get_ipython()       )

  try:
    _snake_case     		=				PrecisionType(mixed_precision.lower()       )
  except ValueError:
    raise ValueError(
        f'''Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.'''       )

  if (in_colab or in_kaggle) and (os.environ.get("TPU_NAME"					,	SCREAMING_SNAKE_CASE__       ) is not None):
    # TPU launch
    import torch_xla.distributed.xla_multiprocessing as xmp

    if len(AcceleratorState._shared_state       ) > 0:
      raise ValueError(
          "To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside "
          "your training function. Restart your notebook and make sure no cells initializes an "
          "`Accelerator`."       )
    if num_processes is None:
      _snake_case     		=				8

    _snake_case     		=				PrepareForLaunch(SCREAMING_SNAKE_CASE__					,	distributed_type="TPU"       )
    print(f'''Launching a training on {num_processes} TPU cores.'''       )
    xmp.spawn(SCREAMING_SNAKE_CASE__					,	args=SCREAMING_SNAKE_CASE__					,	nprocs=SCREAMING_SNAKE_CASE__					,	start_method="fork"       )
  elif in_colab:
    # No need for a distributed launch otherwise as it's either CPU or one GPU.
    if torch.cuda.is_available():
      print("Launching training on one GPU."       )
    else:
      print("Launching training on one CPU."       )
    function(*SCREAMING_SNAKE_CASE__       )
  else:
    if num_processes is None:
      raise ValueError(
          "You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call."       )

    if num_processes > 1:
      # Multi-GPU launch
      from torch.multiprocessing import start_processes
      from torch.multiprocessing.spawn import ProcessRaisedException

      if len(AcceleratorState._shared_state       ) > 0:
        raise ValueError(
            "To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized "
            "inside your training function. Restart your notebook and make sure no cells initializes an "
            "`Accelerator`."       )

      if torch.cuda.is_initialized():
        raise ValueError(
            "To launch a multi-GPU training from your notebook, you need to avoid running any instruction "
            "using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA "
            "function."       )

      # torch.distributed will expect a few environment variable to be here. We set the ones common to each
      # process here (the other ones will be set be the launcher).
      with patch_environment(
          world_size=SCREAMING_SNAKE_CASE__					,	master_addr="127.0.01"					,	master_port=SCREAMING_SNAKE_CASE__					,	mixed_precision=SCREAMING_SNAKE_CASE__       ):
        _snake_case     		=				PrepareForLaunch(SCREAMING_SNAKE_CASE__					,	distributed_type="MULTI_GPU"       )
        print(f'''Launching training on {num_processes} GPUs.'''       )
        try:
          start_processes(SCREAMING_SNAKE_CASE__					,	args=SCREAMING_SNAKE_CASE__					,	nprocs=SCREAMING_SNAKE_CASE__					,	start_method="fork"       )
        except ProcessRaisedException as e:
          if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]:
            raise RuntimeError(
                "CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. "
                "This likely stems from an outside import causing issues once the `notebook_launcher()` is called. "
                "Please review your imports and test them when running the `notebook_launcher()` to identify "
                "which one is problematic."       ) from e

    else:
      # No need for a distributed launch otherwise as it's either CPU, GPU or MPS.
      if is_mps_available():
        _snake_case     		=				"1"
        print("Launching training on MPS."       )
      elif torch.cuda.is_available():
        print("Launching training on one GPU."       )
      else:
        print("Launching training on CPU."       )
      function(*SCREAMING_SNAKE_CASE__       )




def 				snake_case_      (		SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__=()					,	SCREAMING_SNAKE_CASE__=2       ):







  '''simple docstring'''



  from torch.multiprocessing import start_processes

  with tempfile.NamedTemporaryFile() as tmp_file:
    # torch.distributed will expect a few environment variable to be here. We set the ones common to each
    # process here (the other ones will be set be the launcher).
    with patch_environment(
        world_size=SCREAMING_SNAKE_CASE__					,	master_addr="127.0.01"					,	master_port="29500"					,	accelerate_mixed_precision="no"					,	accelerate_debug_rdv_file=tmp_file.name					,	accelerate_use_cpu="yes"					,	):
      _snake_case     		=				PrepareForLaunch(SCREAMING_SNAKE_CASE__					,	debug=SCREAMING_SNAKE_CASE__       )
      start_processes(SCREAMING_SNAKE_CASE__					,	args=SCREAMING_SNAKE_CASE__					,	nprocs=SCREAMING_SNAKE_CASE__					,	start_method="fork"       )









'''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,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


__magic_name__   :						Tuple    =			logging.get_logger(__name__)


if is_vision_available():
 import PIL


class       __SCREAMING_SNAKE_CASE	(						__UpperCamelCase			):



     '''simple docstring'''






     UpperCAmelCase__       :						str      =   ['''pixel_values''']

     def __init__(					self						,   lowerCamelCase = True						,   lowerCamelCase = None						,   lowerCamelCase = PILImageResampling.BICUBIC						,   lowerCamelCase = True						,   lowerCamelCase = None						,   lowerCamelCase = True						,   lowerCamelCase = 1 / 255						,   lowerCamelCase = True						,   lowerCamelCase = None						,   lowerCamelCase = None						,   lowerCamelCase = True						,   **lowerCamelCase						,   ):
       super().__init__(**lowerCamelCase	)
       _snake_case     		=				size if size is not None else {"shortest_edge": 224}
       _snake_case     		=				get_size_dict(lowerCamelCase						,   default_to_square=lowerCamelCase	)
       _snake_case     		=				crop_size if crop_size is not None else {"height": 224, "width": 224}
       _snake_case     		=				get_size_dict(lowerCamelCase						,   default_to_square=lowerCamelCase						,   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 OPENAI_CLIP_MEAN
       _snake_case     		=				image_std if image_std is not None else OPENAI_CLIP_STD
       _snake_case     		=				do_convert_rgb

     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase						,   lowerCamelCase = PILImageResampling.BICUBIC						,   lowerCamelCase = None						,   **lowerCamelCase						,   ):
       _snake_case     		=				get_size_dict(lowerCamelCase						,   default_to_square=lowerCamelCase	)
       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(lowerCamelCase						,   size=size["shortest_edge"]						,   default_to_square=lowerCamelCase	)
       return resize(lowerCamelCase						,   size=lowerCamelCase						,   resample=lowerCamelCase						,   data_format=lowerCamelCase						,   **lowerCamelCase	)

     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase						,   lowerCamelCase = None						,   **lowerCamelCase						,   ):
       _snake_case     		=				get_size_dict(lowerCamelCase	)
       if "height" not in size or "width" not in size:
         raise ValueError(F'''The `size` parameter must contain the keys (height, width). Got {size.keys()}'''	)
       return center_crop(lowerCamelCase						,   size=(size["height"], size["width"])						,   data_format=lowerCamelCase						,   **lowerCamelCase	)

     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase						,   lowerCamelCase = None						,   **lowerCamelCase						,   ):
       return rescale(lowerCamelCase						,   scale=lowerCamelCase						,   data_format=lowerCamelCase						,   **lowerCamelCase	)

     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase						,   lowerCamelCase						,   lowerCamelCase = None						,   **lowerCamelCase						,   ):
       return normalize(lowerCamelCase						,   mean=lowerCamelCase						,   std=lowerCamelCase						,   data_format=lowerCamelCase						,   **lowerCamelCase	)






     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase = None						,   lowerCamelCase = None						,   lowerCamelCase = None						,   lowerCamelCase = None						,   lowerCamelCase = None						,   lowerCamelCase = None						,   lowerCamelCase = None						,   lowerCamelCase = None						,   lowerCamelCase = None						,   lowerCamelCase = None						,   lowerCamelCase = None						,   lowerCamelCase = None						,   lowerCamelCase = ChannelDimension.FIRST						,   **lowerCamelCase						,   ):
       _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(lowerCamelCase						,   param_name="size"						,   default_to_square=lowerCamelCase	)
       _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(lowerCamelCase						,   param_name="crop_size"						,   default_to_square=lowerCamelCase	)
       _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     		=				do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

       _snake_case     		=				make_list_of_images(lowerCamelCase	)

       if not valid_images(lowerCamelCase	):
         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."	)

       # PIL RGBA images are converted to RGB
       if do_convert_rgb:
         _snake_case     		=				[convert_to_rgb(lowerCamelCase	) for image in images]

       # All transformations expect numpy arrays.
       _snake_case     		=				[to_numpy_array(lowerCamelCase	) for image in images]

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

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

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

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

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

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


