

'''simple docstring'''






import inspect
import unittest

import torch
import torch.nn as nn

from accelerate.hooks import (
    AlignDevicesHook,
    ModelHook,
    SequentialHook,
    add_hook_to_module,
    attach_align_device_hook,
    remove_hook_from_module,
    remove_hook_from_submodules,
)
from accelerate.test_utils import require_multi_gpu






class      lowercase_      (nn.Module ):




  """simple docstring"""




  def __init__( self  :	Tuple     ):
   super().__init__()
   __lowercase				    =					nn.Linear(3   ,4     )
   __lowercase				    =					nn.BatchNormad(4     )
   __lowercase				    =					nn.Linear(4   ,5     )






  def    SCREAMING_SNAKE_CASE ( self  :	List[str]   ,lowercase__  :	List[Any]     ):
   return self.lineara(self.batchnorm(self.lineara(lowercase__     )     )     )






class      lowercase_      (lowerCamelCase__ ):




  """simple docstring"""




  def    SCREAMING_SNAKE_CASE ( self  :	List[Any]   ,lowercase__  :	Dict   ,*lowercase__  :	List[str]   ,**lowercase__  :	List[str]     ):
   return (args[0] + 1,) + args[1:], kwargs






class      lowercase_      (lowerCamelCase__ ):




  """simple docstring"""




  def    SCREAMING_SNAKE_CASE ( self  :	List[str]   ,lowercase__  :	Optional[Any]   ,lowercase__  :	Optional[Any]     ):
   return output + 1






class      lowercase_      (unittest.TestCase ):




  """simple docstring"""




  def    SCREAMING_SNAKE_CASE ( self  :	str     ):
   __lowercase				    =					ModelForTest()
   __lowercase				    =					ModelHook()

   add_hook_to_module(lowercase__   ,lowercase__     )
   self.assertEqual(test_model._hf_hook   ,lowercase__     )
   self.assertTrue(hasattr(lowercase__   ,'''_old_forward'''     )     )

   # Check adding the hook did not change the name or the signature
   self.assertEqual(test_model.forward.__name__   ,'''forward'''     )
   self.assertListEqual(list(inspect.signature(test_model.forward     ).parameters     )   ,['''x''']     )

   remove_hook_from_module(lowercase__     )
   self.assertFalse(hasattr(lowercase__   ,'''_hf_hook'''     )     )
   self.assertFalse(hasattr(lowercase__   ,'''_old_forward'''     )     )






  def    SCREAMING_SNAKE_CASE ( self  :	List[str]     ):
   __lowercase				    =					ModelForTest()
   __lowercase				    =					ModelHook()

   add_hook_to_module(lowercase__   ,lowercase__     )
   add_hook_to_module(lowercase__   ,lowercase__   ,append=lowercase__     )

   self.assertEqual(isinstance(test_model._hf_hook   ,lowercase__     )   ,lowercase__     )
   self.assertEqual(len(test_model._hf_hook.hooks     )   ,2     )
   self.assertTrue(hasattr(lowercase__   ,'''_old_forward'''     )     )

   # Check adding the hook did not change the name or the signature
   self.assertEqual(test_model.forward.__name__   ,'''forward'''     )
   self.assertListEqual(list(inspect.signature(test_model.forward     ).parameters     )   ,['''x''']     )

   remove_hook_from_module(lowercase__     )
   self.assertFalse(hasattr(lowercase__   ,'''_hf_hook'''     )     )
   self.assertFalse(hasattr(lowercase__   ,'''_old_forward'''     )     )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[int]     ):
   __lowercase				    =					ModelForTest()
   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					test_model(x + 1     )
   __lowercase				    =					test_model(x + 2     )

   __lowercase				    =					PreForwardHook()
   add_hook_to_module(lowercase__   ,lowercase__     )
   __lowercase				    =					test_model(lowercase__     )
   self.assertTrue(torch.allclose(lowercase__   ,lowercase__   ,atol=1e-5     )     )

   # Attaching a hook to a model when it already has one replaces, does not chain
   __lowercase				    =					PreForwardHook()
   add_hook_to_module(lowercase__   ,lowercase__     )
   __lowercase				    =					test_model(lowercase__     )
   self.assertTrue(torch.allclose(lowercase__   ,lowercase__   ,atol=1e-5     )     )

   # You need to use the sequential hook to chain two or more hooks
   __lowercase				    =					SequentialHook(PreForwardHook()   ,PreForwardHook()     )
   add_hook_to_module(lowercase__   ,lowercase__     )

   __lowercase				    =					test_model(lowercase__     )
   assert torch.allclose(lowercase__   ,lowercase__   ,atol=1e-5     )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[int]     ):
   __lowercase				    =					ModelForTest()
   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					test_model(lowercase__     )

   __lowercase				    =					PostForwardHook()
   add_hook_to_module(lowercase__   ,lowercase__     )
   __lowercase				    =					test_model(lowercase__     )
   self.assertTrue(torch.allclose(lowercase__   ,output + 1   ,atol=1e-5     )     )

   # Attaching a hook to a model when it already has one replaces, does not chain
   __lowercase				    =					PostForwardHook()
   add_hook_to_module(lowercase__   ,lowercase__     )
   __lowercase				    =					test_model(lowercase__     )
   self.assertTrue(torch.allclose(lowercase__   ,output + 1   ,atol=1e-5     )     )

   # You need to use the sequential hook to chain two or more hooks
   __lowercase				    =					SequentialHook(PostForwardHook()   ,PostForwardHook()     )
   add_hook_to_module(lowercase__   ,lowercase__     )

   __lowercase				    =					test_model(lowercase__     )
   assert torch.allclose(lowercase__   ,output + 2   ,atol=1e-5     )






  def    SCREAMING_SNAKE_CASE ( self  :	int     ):
   __lowercase				    =					ModelForTest()
   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					test_model(lowercase__     )

   __lowercase				    =					PostForwardHook()
   add_hook_to_module(lowercase__   ,lowercase__     )
   __lowercase				    =					test_model(lowercase__     )
   self.assertTrue(torch.allclose(lowercase__   ,output + 1     )     )
   self.assertTrue(outputa.requires_grad     )

   __lowercase				    =					True
   __lowercase				    =					test_model(lowercase__     )
   self.assertFalse(outputa.requires_grad     )






  @require_multi_gpu
  def    SCREAMING_SNAKE_CASE ( self  :	Dict     ):
   __lowercase				    =					ModelForTest()
   # Everything is on CPU
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # This will move each submodule on different devices
   add_hook_to_module(model.lineara   ,AlignDevicesHook(execution_device=0     )     )
   add_hook_to_module(model.batchnorm   ,AlignDevicesHook(execution_device=0     )     )
   add_hook_to_module(model.lineara   ,AlignDevicesHook(execution_device=1     )     )

   self.assertEqual(model.lineara.weight.device   ,torch.device(0     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device(0     )     )
   self.assertEqual(model.batchnorm.running_mean.device   ,torch.device(0     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device(1     )     )

   # We can still make a forward pass. The input does not need to be on any particular device
   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,torch.device(1     )     )

   # We can add a general hook to put back output on same device as input.
   add_hook_to_module(lowercase__   ,AlignDevicesHook(io_same_device=lowercase__     )     )
   __lowercase				    =					torch.randn(2   ,3     ).to(0     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,torch.device(0     )     )






  def    SCREAMING_SNAKE_CASE ( self  :	str     ):
   __lowercase				    =					ModelForTest()

   # Everything is on CPU
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # This will move each submodule on different devices
   __lowercase				    =					{'''execution_device''': 0 if torch.cuda.is_available() else '''cpu''', '''offload''': True}

   add_hook_to_module(model.lineara   ,AlignDevicesHook(**lowercase__     )     )
   add_hook_to_module(model.batchnorm   ,AlignDevicesHook(**lowercase__     )     )
   add_hook_to_module(model.lineara   ,AlignDevicesHook(**lowercase__     )     )

   # Parameters have been offloaded, so on the meta device
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   # Buffers are not included in the offload by default, so are on the execution device
   __lowercase				    =					torch.device(hook_kwargs['''execution_device''']     )
   self.assertEqual(model.batchnorm.running_mean.device   ,lowercase__     )

   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,lowercase__     )

   # Removing hooks loads back the weights in the model.
   remove_hook_from_module(model.lineara     )
   remove_hook_from_module(model.batchnorm     )
   remove_hook_from_module(model.lineara     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # Now test with buffers included in the offload
   __lowercase				    =					{
       '''execution_device''': 0 if torch.cuda.is_available() else '''cpu''',
       '''offload''': True,
       '''offload_buffers''': True,
   }

   add_hook_to_module(model.lineara   ,AlignDevicesHook(**lowercase__     )     )
   add_hook_to_module(model.batchnorm   ,AlignDevicesHook(**lowercase__     )     )
   add_hook_to_module(model.lineara   ,AlignDevicesHook(**lowercase__     )     )

   # Parameters have been offloaded, so on the meta device, buffers included
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.running_mean.device   ,torch.device('''meta'''     )     )

   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,lowercase__     )

   # Removing hooks loads back the weights in the model.
   remove_hook_from_module(model.lineara     )
   remove_hook_from_module(model.batchnorm     )
   remove_hook_from_module(model.lineara     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )






  def    SCREAMING_SNAKE_CASE ( self  :	int     ):
   __lowercase				    =					ModelForTest()

   # Everything is on CPU
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # This will move each submodule on different devices
   __lowercase				    =					0 if torch.cuda.is_available() else '''cpu'''
   attach_align_device_hook(lowercase__   ,execution_device=lowercase__   ,offload=lowercase__     )

   # Parameters have been offloaded, so on the meta device
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   # Buffers are not included in the offload by default, so are on the execution device
   __lowercase				    =					torch.device(lowercase__     )
   self.assertEqual(model.batchnorm.running_mean.device   ,lowercase__     )

   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,lowercase__     )

   # Removing hooks loads back the weights in the model.
   remove_hook_from_submodules(lowercase__     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # Now test with buffers included in the offload
   attach_align_device_hook(lowercase__   ,execution_device=lowercase__   ,offload=lowercase__   ,offload_buffers=lowercase__     )

   # Parameters have been offloaded, so on the meta device, buffers included
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.running_mean.device   ,torch.device('''meta'''     )     )

   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,lowercase__     )

   # Removing hooks loads back the weights in the model.
   remove_hook_from_submodules(lowercase__     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )






  def    SCREAMING_SNAKE_CASE ( self  :	List[Any]     ):
   __lowercase				    =					ModelForTest()

   # Everything is on CPU
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # This will move each submodule on different devices
   __lowercase				    =					0 if torch.cuda.is_available() else '''cpu'''
   attach_align_device_hook(
       lowercase__   ,execution_device=lowercase__   ,offload=lowercase__   ,weights_map=model.state_dict()     )

   # Parameters have been offloaded, so on the meta device
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   # Buffers are not included in the offload by default, so are on the execution device
   __lowercase				    =					torch.device(lowercase__     )
   self.assertEqual(model.batchnorm.running_mean.device   ,lowercase__     )

   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,lowercase__     )

   # Removing hooks loads back the weights in the model.
   remove_hook_from_submodules(lowercase__     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # Now test with buffers included in the offload
   attach_align_device_hook(
       lowercase__   ,execution_device=lowercase__   ,offload=lowercase__   ,weights_map=model.state_dict()   ,offload_buffers=lowercase__   ,)

   # Parameters have been offloaded, so on the meta device, buffers included
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.running_mean.device   ,torch.device('''meta'''     )     )

   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,lowercase__     )

   # Removing hooks loads back the weights in the model.
   remove_hook_from_submodules(lowercase__     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )





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


snake_case__				:	Tuple					       =					logging.get_logger(__name__)


if is_vision_available():
      import PIL





class   SCREAMING_SNAKE_CASE_			(a__						):




       '''simple docstring'''



       _a   							=							["pixel_values"]



       def __init__(						self				:				List[str]		,				__a				:				bool = True		,				__a				:				Dict[str, int] = None		,				__a				:				PILImageResampling = PILImageResampling.BICUBIC		,				__a				:				bool = True		,				__a				:				Dict[str, int] = None		,				__a				:				bool = True		,				__a				:				Union[int, float] = 1 / 255		,				__a				:				bool = True		,				__a				:				Optional[Union[float, List[float]]] = None		,				__a				:				Optional[Union[float, List[float]]] = None		,				__a				:				bool = True		,				**__a				:				str		,				)					->None:
          super().__init__(**__a							)
          lowerCamelCase_						:   Any		= size if size is not None else {"""shortest_edge""": 224}
          lowerCamelCase_						:   List[Any]		= get_size_dict(__a		,				default_to_square=__a							)
          lowerCamelCase_						:   List[str]		= crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
          lowerCamelCase_						:   Any		= get_size_dict(__a		,				default_to_square=__a		,				param_name="""crop_size"""							)

          lowerCamelCase_						:   List[Any]		= do_resize
          lowerCamelCase_						:   str		= size
          lowerCamelCase_						:   Any		= resample
          lowerCamelCase_						:   List[Any]		= do_center_crop
          lowerCamelCase_						:   Any		= crop_size
          lowerCamelCase_						:   List[Any]		= do_rescale
          lowerCamelCase_						:   Tuple		= rescale_factor
          lowerCamelCase_						:   Dict		= do_normalize
          lowerCamelCase_						:   Any		= image_mean if image_mean is not None else OPENAI_CLIP_MEAN
          lowerCamelCase_						:   int		= image_std if image_std is not None else OPENAI_CLIP_STD
          lowerCamelCase_						:   Tuple		= do_convert_rgb



       def 				_lowerCAmelCase							(						self				:				int		,				__a				:				np.ndarray		,				__a				:				Dict[str, int]		,				__a				:				PILImageResampling = PILImageResampling.BICUBIC		,				__a				:				Optional[Union[str, ChannelDimension]] = None		,				**__a				:				Dict		,				)					->np.ndarray:
          lowerCamelCase_						:   Optional[Any]		= 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_						:   Dict		= 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 				_lowerCAmelCase							(						self				:				Union[str, Any]		,				__a				:				np.ndarray		,				__a				:				Dict[str, int]		,				__a				:				Optional[Union[str, ChannelDimension]] = None		,				**__a				:				List[Any]		,				)					->np.ndarray:
          lowerCamelCase_						:   List[Any]		= 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, width). Got {size.keys()}'''							)
          return center_crop(__a		,				size=(size["""height"""], size["""width"""])		,				data_format=__a		,				**__a							)



       def 				_lowerCAmelCase							(						self				:				Optional[Any]		,				__a				:				np.ndarray		,				__a				:				Union[int, float]		,				__a				:				Optional[Union[str, ChannelDimension]] = None		,				**__a				:				Dict		,				)					->Dict:
          return rescale(__a		,				scale=__a		,				data_format=__a		,				**__a							)



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




       def 				_lowerCAmelCase							(						self				:				str		,				__a				:				ImageInput		,				__a				:				bool = None		,				__a				:				Dict[str, int] = None		,				__a				:				PILImageResampling = None		,				__a				:				bool = None		,				__a				:				int = None		,				__a				:				bool = None		,				__a				:				float = None		,				__a				:				bool = None		,				__a				:				Optional[Union[float, List[float]]] = None		,				__a				:				Optional[Union[float, List[float]]] = None		,				__a				:				bool = None		,				__a				:				Optional[Union[str, TensorType]] = None		,				__a				:				Optional[ChannelDimension] = ChannelDimension.FIRST		,				**__a				:				List[str]		,				)					->PIL.Image.Image:
          lowerCamelCase_						:   List[Any]		= do_resize if do_resize is not None else self.do_resize
          lowerCamelCase_						:   Any		= size if size is not None else self.size
          lowerCamelCase_						:   str		= get_size_dict(__a		,				param_name="""size"""		,				default_to_square=__a							)
          lowerCamelCase_						:   List[str]		= resample if resample is not None else self.resample
          lowerCamelCase_						:   List[str]		= do_center_crop if do_center_crop is not None else self.do_center_crop
          lowerCamelCase_						:   List[Any]		= crop_size if crop_size is not None else self.crop_size
          lowerCamelCase_						:   Optional[int]		= get_size_dict(__a		,				param_name="""crop_size"""		,				default_to_square=__a							)
          lowerCamelCase_						:   List[Any]		= do_rescale if do_rescale is not None else self.do_rescale
          lowerCamelCase_						:   List[str]		= rescale_factor if rescale_factor is not None else self.rescale_factor
          lowerCamelCase_						:   Dict		= do_normalize if do_normalize is not None else self.do_normalize
          lowerCamelCase_						:   Dict		= image_mean if image_mean is not None else self.image_mean
          lowerCamelCase_						:   Tuple		= image_std if image_std is not None else self.image_std
          lowerCamelCase_						:   Union[str, Any]		= do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

          lowerCamelCase_						:   Union[str, Any]		= 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."""							)

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

          # All transformations expect numpy arrays.
          lowerCamelCase_						:   str		= [to_numpy_array(__a							) for image in images]

          if do_resize:
             lowerCamelCase_						:   int		= [self.resize(image=__a		,				size=__a		,				resample=__a							) for image in images]

          if do_center_crop:
             lowerCamelCase_						:   Dict		= [self.center_crop(image=__a		,				size=__a							) for image in images]

          if do_rescale:
             lowerCamelCase_						:   List[str]		= [self.rescale(image=__a		,				scale=__a							) for image in images]

          if do_normalize:
             lowerCamelCase_						:   Tuple		= [self.normalize(image=__a		,				mean=__a		,				std=__a							) for image in images]

          lowerCamelCase_						:   Tuple		= [to_channel_dimension_format(__a		,				__a							) for image in images]

          lowerCamelCase_						:   Tuple		= {"""pixel_values""": images}
          return BatchFeature(data=__a		,				tensor_type=__a							)





