




'''simple docstring'''




import json
import os
import tempfile

from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available


if is_torch_available():
     import numpy as np
     import torch

if is_vision_available():
     from PIL import Image

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      List[str]       ,						SCREAMING_SNAKE_CASE__			:      List[str]=False       ,						SCREAMING_SNAKE_CASE__			:      List[Any]=False       ,						SCREAMING_SNAKE_CASE__			:      List[Any]=False       ):
 '''simple docstring'''





 assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

 UpperCAmelCase__										=    []
 for i in range(image_processor_tester.batch_size       ):
  if equal_resolution:
   UpperCAmelCase__										=    UpperCAmelCase__										=    image_processor_tester.max_resolution
  else:
   # To avoid getting image width/height 0
   UpperCAmelCase__										=    image_processor_tester.min_resolution
   if getattr(SCREAMING_SNAKE_CASE__       ,						"""size_divisor"""       ,						SCREAMING_SNAKE_CASE__       ):
    # If `size_divisor` is defined, the image needs to have width/size >= `size_divisor`
    UpperCAmelCase__										=    max(image_processor_tester.size_divisor       ,						SCREAMING_SNAKE_CASE__       )
   UpperCAmelCase__							,			UpperCAmelCase__										=    np.random.choice(np.arange(SCREAMING_SNAKE_CASE__       ,						image_processor_tester.max_resolution       )       ,						2       )
  image_inputs.append(
      np.random.randint(255       ,						size=(image_processor_tester.num_channels, width, height)       ,						dtype=np.uinta       )       )

 if not numpify and not torchify:
  # PIL expects the channel dimension as last dimension
  UpperCAmelCase__										=    [Image.fromarray(np.moveaxis(SCREAMING_SNAKE_CASE__       ,						0       ,						-1       )       ) for image in image_inputs]

 if torchify:
  UpperCAmelCase__										=    [torch.from_numpy(SCREAMING_SNAKE_CASE__       ) for image in image_inputs]

 return image_inputs

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      str       ,						SCREAMING_SNAKE_CASE__			:      List[str]=10       ,						SCREAMING_SNAKE_CASE__			:      int=10       ,						SCREAMING_SNAKE_CASE__			:      Any=False       ,						SCREAMING_SNAKE_CASE__			:      Optional[int]=False       ):
 '''simple docstring'''





 UpperCAmelCase__										=    []
 for i in range(image_processor_tester.num_frames       ):
  video.append(np.random.randint(255       ,						size=(image_processor_tester.num_channels, width, height)       ,						dtype=np.uinta       )       )

 if not numpify and not torchify:
  # PIL expects the channel dimension as last dimension
  UpperCAmelCase__										=    [Image.fromarray(np.moveaxis(SCREAMING_SNAKE_CASE__       ,						0       ,						-1       )       ) for frame in video]

 if torchify:
  UpperCAmelCase__										=    [torch.from_numpy(SCREAMING_SNAKE_CASE__       ) for frame in video]

 return video

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      Tuple       ,						SCREAMING_SNAKE_CASE__			:      Optional[Any]=False       ,						SCREAMING_SNAKE_CASE__			:      Any=False       ,						SCREAMING_SNAKE_CASE__			:      Tuple=False       ):
 '''simple docstring'''





 assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

 UpperCAmelCase__										=    []
 for i in range(image_processor_tester.batch_size       ):
  if equal_resolution:
   UpperCAmelCase__										=    UpperCAmelCase__										=    image_processor_tester.max_resolution
  else:
   UpperCAmelCase__							,			UpperCAmelCase__										=    np.random.choice(
       np.arange(image_processor_tester.min_resolution       ,						image_processor_tester.max_resolution       )       ,						2       )
   UpperCAmelCase__										=    prepare_video(
       image_processor_tester=SCREAMING_SNAKE_CASE__       ,						width=SCREAMING_SNAKE_CASE__       ,						height=SCREAMING_SNAKE_CASE__       ,						numpify=SCREAMING_SNAKE_CASE__       ,						torchify=SCREAMING_SNAKE_CASE__       ,						)
  video_inputs.append(SCREAMING_SNAKE_CASE__       )

 return video_inputs







class 						lowerCAmelCase_   :







  '''simple docstring'''







  lowerCAmelCase_				:					Dict				     =						None


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int] ):






   """simple docstring"""






   UpperCAmelCase__										=    self.image_processing_class(**self.image_processor_dict )
   UpperCAmelCase__										=    json.loads(image_processor.to_json_string() )
   for key, value in self.image_processor_dict.items():
    self.assertEqual(obj[key]						,		_UpperCAmelCase )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	List[str] ):






   """simple docstring"""






   UpperCAmelCase__										=    self.image_processing_class(**self.image_processor_dict )

   with tempfile.TemporaryDirectory() as tmpdirname:
    UpperCAmelCase__										=    os.path.join(_UpperCAmelCase						,		"""image_processor.json""" )
    image_processor_first.to_json_file(_UpperCAmelCase )
    UpperCAmelCase__										=    self.image_processing_class.from_json_file(_UpperCAmelCase )

   self.assertEqual(image_processor_second.to_dict()						,		image_processor_first.to_dict() )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int] ):






   """simple docstring"""






   UpperCAmelCase__										=    self.image_processing_class(**self.image_processor_dict )

   with tempfile.TemporaryDirectory() as tmpdirname:
    UpperCAmelCase__										=    image_processor_first.save_pretrained(_UpperCAmelCase )[0]
    check_json_file_has_correct_format(_UpperCAmelCase )
    UpperCAmelCase__										=    self.image_processing_class.from_pretrained(_UpperCAmelCase )

   self.assertEqual(image_processor_second.to_dict()						,		image_processor_first.to_dict() )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	List[Any] ):






   """simple docstring"""






   UpperCAmelCase__										=    self.image_processing_class()
   self.assertIsNotNone(_UpperCAmelCase )



  @require_torch
  @require_vision
  def 							SCREAMING_SNAKE_CASE__			(						self    :	str ):






   """simple docstring"""






   if self.test_cast_dtype is not None:
    # Initialize image_processor
    UpperCAmelCase__										=    self.image_processing_class(**self.image_processor_dict )

    # create random PyTorch tensors
    UpperCAmelCase__										=    prepare_image_inputs(self.image_processor_tester						,		equal_resolution=_UpperCAmelCase						,		torchify=_UpperCAmelCase )

    UpperCAmelCase__										=    image_processor(_UpperCAmelCase						,		return_tensors="""pt""" )
    # for layoutLM compatiblity
    self.assertEqual(encoding.pixel_values.device						,		torch.device("""cpu""" ) )
    self.assertEqual(encoding.pixel_values.dtype						,		torch.floataa )

    UpperCAmelCase__										=    image_processor(_UpperCAmelCase						,		return_tensors="""pt""" ).to(torch.floataa )
    self.assertEqual(encoding.pixel_values.device						,		torch.device("""cpu""" ) )
    self.assertEqual(encoding.pixel_values.dtype						,		torch.floataa )

    UpperCAmelCase__										=    image_processor(_UpperCAmelCase						,		return_tensors="""pt""" ).to("""cpu"""						,		torch.bfloataa )
    self.assertEqual(encoding.pixel_values.device						,		torch.device("""cpu""" ) )
    self.assertEqual(encoding.pixel_values.dtype						,		torch.bfloataa )

    with self.assertRaises(_UpperCAmelCase ):
     UpperCAmelCase__										=    image_processor(_UpperCAmelCase						,		return_tensors="""pt""" ).to(torch.bfloataa						,		"""cpu""" )

    # Try with text + image feature
    UpperCAmelCase__										=    image_processor(_UpperCAmelCase						,		return_tensors="""pt""" )
    encoding.update({"""input_ids""": torch.LongTensor([[1, 2, 3], [4, 5, 6]] )} )
    UpperCAmelCase__										=    encoding.to(torch.floataa )

    self.assertEqual(encoding.pixel_values.device						,		torch.device("""cpu""" ) )
    self.assertEqual(encoding.pixel_values.dtype						,		torch.floataa )
    self.assertEqual(encoding.input_ids.dtype						,		torch.long )






'''simple docstring'''




import inspect
import warnings

import torch

from .state import AcceleratorState, GradientState
from .utils import DistributedType, honor_type, is_tpu_available


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

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      Tuple       ,						SCREAMING_SNAKE_CASE__			:      Dict       ):
 '''simple docstring'''





 if isinstance(SCREAMING_SNAKE_CASE__       ,						(list, tuple)       ):
  return honor_type(SCREAMING_SNAKE_CASE__       ,						(move_to_device(SCREAMING_SNAKE_CASE__       ,						SCREAMING_SNAKE_CASE__       ) for t in state)       )
 elif isinstance(SCREAMING_SNAKE_CASE__       ,						SCREAMING_SNAKE_CASE__       ):
  return type(SCREAMING_SNAKE_CASE__       )({k: move_to_device(SCREAMING_SNAKE_CASE__       ,						SCREAMING_SNAKE_CASE__       ) for k, v in state.items()}       )
 elif isinstance(SCREAMING_SNAKE_CASE__       ,						torch.Tensor       ):
  return state.to(SCREAMING_SNAKE_CASE__       )
 return state







class 						lowerCAmelCase_   ( torch.optim.Optimizer   ):







  '''simple docstring'''







  def __init__(						self    :	List[str]						,		_UpperCAmelCase    :	Any						,		_UpperCAmelCase    :	Union[str, Any]=True						,		_UpperCAmelCase    :	List[str]=None ):






   """simple docstring"""






   UpperCAmelCase__										=    optimizer
   UpperCAmelCase__										=    scaler
   UpperCAmelCase__										=    AcceleratorState()
   UpperCAmelCase__										=    GradientState()
   UpperCAmelCase__										=    device_placement
   UpperCAmelCase__										=    False
   UpperCAmelCase__										=    None

   # Handle device placement
   if device_placement:
    UpperCAmelCase__										=    self.optimizer.state_dict()
    if self.accelerator_state.distributed_type == DistributedType.TPU:
     xm.send_cpu_data_to_device(_UpperCAmelCase						,		self.accelerator_state.device )
    else:
     UpperCAmelCase__										=    move_to_device(_UpperCAmelCase						,		self.accelerator_state.device )
    self.optimizer.load_state_dict(_UpperCAmelCase )


  @property
  def 							SCREAMING_SNAKE_CASE__			(						self    :	Dict ):






   """simple docstring"""






   return self.optimizer.state


  @state.setter
  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int]						,		_UpperCAmelCase    :	List[str] ):






   """simple docstring"""






   UpperCAmelCase__										=    state


  @property
  def 							SCREAMING_SNAKE_CASE__			(						self    :	Any ):






   """simple docstring"""






   return self.optimizer.param_groups


  @param_groups.setter
  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int]						,		_UpperCAmelCase    :	List[Any] ):






   """simple docstring"""






   UpperCAmelCase__										=    param_groups


  @property
  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[Any] ):






   """simple docstring"""






   return self.optimizer.defaults


  @defaults.setter
  def 							SCREAMING_SNAKE_CASE__			(						self    :	int						,		_UpperCAmelCase    :	str ):






   """simple docstring"""






   UpperCAmelCase__										=    defaults


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int]						,		_UpperCAmelCase    :	Union[str, Any] ):






   """simple docstring"""






   self.optimizer.add_param_group(_UpperCAmelCase )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	List[str]						,		_UpperCAmelCase    :	Tuple ):






   """simple docstring"""






   if self.accelerator_state.distributed_type == DistributedType.TPU and self.device_placement:
    xm.send_cpu_data_to_device(_UpperCAmelCase						,		self.accelerator_state.device )
   self.optimizer.load_state_dict(_UpperCAmelCase )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	str ):






   """simple docstring"""






   return self.optimizer.state_dict()


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int]						,		_UpperCAmelCase    :	List[Any]=None ):






   """simple docstring"""






   if self.gradient_state.sync_gradients:
    UpperCAmelCase__										=    """set_to_none""" in inspect.signature(self.optimizer.zero_grad ).parameters
    if accept_arg:
     if set_to_none is None:
      UpperCAmelCase__										=    False
     self.optimizer.zero_grad(set_to_none=_UpperCAmelCase )
    else:
     if set_to_none is not None:
      raise ValueError("""`set_to_none` for Optimizer.zero_grad` is not supported by this optimizer.""" )
     self.optimizer.zero_grad()


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Any						,		_UpperCAmelCase    :	List[str]=None ):






   """simple docstring"""






   if self.gradient_state.sync_gradients:
    if self.accelerator_state.distributed_type == DistributedType.TPU:
     UpperCAmelCase__										=    {"""closure""": closure} if closure is not None else {}
     xm.optimizer_step(self.optimizer						,		optimizer_args=_UpperCAmelCase )
    elif self.scaler is not None:
     UpperCAmelCase__										=    False
     if self._last_scale is None:
      # `get_scale` is an async operation requiring full synchronization
      # on CPU and GPUs before finishing. As a result, we store away
      # the prior one to reduce the call overhead
      UpperCAmelCase__										=    self.scaler.get_scale()
      UpperCAmelCase__										=    True
     self.scaler.step(self.optimizer						,		_UpperCAmelCase )
     self.scaler.update()
     UpperCAmelCase__										=    self.scaler.get_scale()
     if not new_scale:
      # If we reduced the loss scale, it means the optimizer step was skipped because of gradient overflow.
      UpperCAmelCase__										=    scale_after < self._last_scale
     UpperCAmelCase__										=    scale_after

    else:
     self.optimizer.step(_UpperCAmelCase )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[Any]						,		_UpperCAmelCase    :	str ):






   """simple docstring"""






   for param_group in self.optimizer.param_groups:
    UpperCAmelCase__										=    [parameters_map.get(_UpperCAmelCase						,		_UpperCAmelCase ) for p in param_group["""params"""]]


  @property
  def 							SCREAMING_SNAKE_CASE__			(						self    :	str ):






   """simple docstring"""






   warnings.warn(
       """The `is_overflow` property is deprecated and will be removed in version 1.0 of Accelerate use """
       """`optimizer.step_was_skipped` instead."""						,		_UpperCAmelCase						,		)
   return self._is_overflow


  @property
  def 							SCREAMING_SNAKE_CASE__			(						self    :	Optional[int] ):






   """simple docstring"""






   return self._is_overflow


  def __getstate__(						self    :	Dict ):






   """simple docstring"""






   return self.__dict__.copy()



  def __setstate__(						self    :	Dict						,		_UpperCAmelCase    :	Tuple ):






   """simple docstring"""






   self.__dict__.update(_UpperCAmelCase )
