




import tempfile
import unittest

import transformers
from transformers import XGLMConfig, XGLMTokenizer, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, require_sentencepiece, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
      import jax
      import jax.numpy as jnp
      import numpy as np

      from transformers.modeling_flax_pytorch_utils import (
          convert_pytorch_state_dict_to_flax,
          load_flax_weights_in_pytorch_model,
      )
      from transformers.models.xglm.modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel


if is_torch_available():
      import torch






@require_flax
class 			A			:
     """simple docstring"""

     def __init__(    self  :   List[str]	,  A__  :   Tuple	,  A__  :   Optional[Any]=1_4	,  A__  :   int=7	,  A__  :   Tuple=True	,  A__  :   Tuple=True	,  A__  :   Any=True	,  A__  :   Dict=9_9	,  A__  :   Any=3_2	,  A__  :   List[str]=5	,  A__  :   str=4	,  A__  :   Union[str, Any]=3_7	,  A__  :   Optional[int]="gelu"	,  A__  :   Optional[Any]=0.1	,  A__  :   Tuple=0.1	,  A__  :   Tuple=5_1_2	,  A__  :   Dict=0.02	,  A__  :   Optional[Any]=None	,  )				->       List[Any]:
           lowerCamelCase__        =				parent
           lowerCamelCase__        =				batch_size
           lowerCamelCase__        =				seq_length
           lowerCamelCase__        =				is_training
           lowerCamelCase__        =				use_input_mask
           lowerCamelCase__        =				use_labels
           lowerCamelCase__        =				vocab_size
           lowerCamelCase__        =				d_model
           lowerCamelCase__        =				num_hidden_layers
           lowerCamelCase__        =				num_attention_heads
           lowerCamelCase__        =				ffn_dim
           lowerCamelCase__        =				activation_function
           lowerCamelCase__        =				activation_dropout
           lowerCamelCase__        =				attention_dropout
           lowerCamelCase__        =				max_position_embeddings
           lowerCamelCase__        =				initializer_range
           lowerCamelCase__        =				None
           lowerCamelCase__        =				0
           lowerCamelCase__        =				2
           lowerCamelCase__        =				1




     def  __snake_case   (    self  :   str			)				->       str:
           lowerCamelCase__        =				np.clip(ids_tensor([self.batch_size, self.seq_length]	,  self.vocab_size			)	,  3	,  self.vocab_size			)

           lowerCamelCase__        =				None
           if self.use_input_mask:
                 lowerCamelCase__        =				random_attention_mask([self.batch_size, self.seq_length]			)

           lowerCamelCase__        =				XGLMConfig(
               vocab_size=self.vocab_size	,  d_model=self.hidden_size	,  num_layers=self.num_hidden_layers	,  attention_heads=self.num_attention_heads	,  ffn_dim=self.ffn_dim	,  activation_function=self.activation_function	,  activation_dropout=self.activation_dropout	,  attention_dropout=self.attention_dropout	,  max_position_embeddings=self.max_position_embeddings	,  initializer_range=self.initializer_range	,  use_cache=A__	,  bos_token_id=self.bos_token_id	,  eos_token_id=self.eos_token_id	,  pad_token_id=self.pad_token_id	,  )

           return (config, input_ids, input_mask)




     def  __snake_case   (    self  :   str			)				->       Tuple:
           lowerCamelCase__        =				self.prepare_config_and_inputs()
           lowerCamelCase__  ,		lowerCamelCase__  ,		lowerCamelCase__        =				config_and_inputs
           lowerCamelCase__        =				{'input_ids': input_ids, 'attention_mask': attention_mask}
           return config, inputs_dict




     def  __snake_case   (    self  :   Tuple			)				->       Any:
           lowerCamelCase__  ,		lowerCamelCase__  ,		lowerCamelCase__        =				self.prepare_config_and_inputs()

           lowerCamelCase__        =				floats_tensor([self.batch_size, self.seq_length, self.hidden_size]			)
           lowerCamelCase__        =				ids_tensor([self.batch_size, self.seq_length]	,  vocab_size=2			)

           return (
               config,
               input_ids,
               attention_mask,
               encoder_hidden_states,
               encoder_attention_mask,
           )




     def  __snake_case   (    self  :   Union[str, Any]	,  A__  :   List[str]	,  A__  :   List[Any]	,  A__  :   Optional[Any]	,  A__  :   str			)				->       Dict:
           lowerCamelCase__        =				2_0
           lowerCamelCase__        =				model_class_name(A__			)

           lowerCamelCase__        =				model.init_cache(input_ids.shape[0]	,  A__			)
           lowerCamelCase__        =				jnp.ones((input_ids.shape[0], max_decoder_length)	,  dtype='i4'			)

           lowerCamelCase__        =				jnp.broadcast_to(
               jnp.arange(input_ids.shape[-1] - 1			)[None, :]	,  (input_ids.shape[0], input_ids.shape[-1] - 1)			)
           lowerCamelCase__        =				model(
               input_ids[:, :-1]	,  attention_mask=A__	,  past_key_values=A__	,  position_ids=A__	,  )

           lowerCamelCase__        =				jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]	,  dtype='i4'			)
           lowerCamelCase__        =				model(
               input_ids[:, -1:]	,  attention_mask=A__	,  past_key_values=outputs_cache.past_key_values	,  position_ids=A__	,  )

           lowerCamelCase__        =				model(A__			)

           lowerCamelCase__        =				np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])			)			)
           self.parent.assertTrue(diff < 1E-3	,  msg=F"""Max diff is {diff}"""			)




     def  __snake_case   (    self  :   Union[str, Any]	,  A__  :   Tuple	,  A__  :   Optional[Any]	,  A__  :   Tuple	,  A__  :   List[Any]			)				->       int:
           lowerCamelCase__        =				2_0
           lowerCamelCase__        =				model_class_name(A__			)

           lowerCamelCase__        =				jnp.concatenate(
               [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])			)]	,  axis=-1	,  )

           lowerCamelCase__        =				model.init_cache(input_ids.shape[0]	,  A__			)
           lowerCamelCase__        =				jnp.broadcast_to(
               jnp.arange(input_ids.shape[-1] - 1			)[None, :]	,  (input_ids.shape[0], input_ids.shape[-1] - 1)			)

           lowerCamelCase__        =				model(
               input_ids[:, :-1]	,  attention_mask=A__	,  past_key_values=A__	,  position_ids=A__	,  )
           lowerCamelCase__        =				jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]	,  dtype='i4'			)
           lowerCamelCase__        =				model(
               input_ids[:, -1:]	,  past_key_values=outputs_cache.past_key_values	,  attention_mask=A__	,  position_ids=A__	,  )

           lowerCamelCase__        =				model(A__	,  attention_mask=A__			)
           lowerCamelCase__        =				np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])			)			)
           self.parent.assertTrue(diff < 1E-3	,  msg=F"""Max diff is {diff}"""			)






@require_sentencepiece
@require_flax
class 			A			(		_lowerCAmelCase			,						_lowerCAmelCase			,						unittest.TestCase		):
     """simple docstring"""

     _snake_case:	Dict     =(FlaxXGLMModel, FlaxXGLMForCausalLM) if is_flax_available() else ()
     _snake_case:	str     =(FlaxXGLMForCausalLM,) if is_flax_available() else ()




     def  __snake_case   (    self  :   Tuple			)				->       List[Any]:
           lowerCamelCase__        =				FlaxXGLMModelTester(self			)




     def  __snake_case   (    self  :   int			)				->       str:
           for model_class_name in self.all_model_classes:
                 lowerCamelCase__  ,		lowerCamelCase__  ,		lowerCamelCase__        =				self.model_tester.prepare_config_and_inputs()
                 self.model_tester.check_use_cache_forward(A__	,  A__	,  A__	,  A__			)




     def  __snake_case   (    self  :   Optional[int]			)				->       str:
           for model_class_name in self.all_model_classes:
                 lowerCamelCase__  ,		lowerCamelCase__  ,		lowerCamelCase__        =				self.model_tester.prepare_config_and_inputs()
                 self.model_tester.check_use_cache_forward_with_attn_mask(
                     A__	,  A__	,  A__	,  A__			)




     @slow
     def  __snake_case   (    self  :   Any			)				->       str:
           lowerCamelCase__        =				XGLMTokenizer.from_pretrained('XGLM'	,  padding_side='left'			)
           lowerCamelCase__        =				tokenizer(['Hello this is a long string', 'Hey']	,  return_tensors='np'	,  padding=A__	,  truncation=A__			)

           lowerCamelCase__        =				FlaxXGLMForCausalLM.from_pretrained('facebook/xglm-564M'			)
           lowerCamelCase__        =				1
           lowerCamelCase__        =				False

           lowerCamelCase__        =				jax.jit(model.generate			)

           lowerCamelCase__        =				jit_generate(inputs['input_ids']	,  attention_mask=inputs['attention_mask']			).sequences

           lowerCamelCase__        =				tokenizer.batch_decode(A__	,  skip_special_tokens=A__			)

           lowerCamelCase__        =				[
               'Hello this is a long string of questions, but I\'m not sure if I\'m',
               'Hey, I\'m a newbie to the forum and I\'',
           ]

           self.assertListEqual(A__	,  A__			)




     @is_pt_flax_cross_test
     def  __snake_case   (    self  :   Optional[int]			)				->       Optional[int]:
           lowerCamelCase__  ,		lowerCamelCase__        =				self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                 with self.subTest(model_class.__name__			):
                       # prepare inputs
                       lowerCamelCase__        =				self._prepare_for_class(A__	,  A__			)
                       lowerCamelCase__        =				{k: torch.tensor(v.tolist()			) for k, v in prepared_inputs_dict.items()}

                       # load corresponding PyTorch class
                       lowerCamelCase__        =				model_class.__name__[4:]  # Skip the "Flax" at the beginning
                       lowerCamelCase__        =				getattr(A__	,  A__			)

                       lowerCamelCase__  ,		lowerCamelCase__        =				pt_inputs['input_ids'].shape
                       lowerCamelCase__        =				np.random.randint(0	,  seq_length - 1	,  size=(batch_size,)			)
                       for batch_idx, start_index in enumerate(A__			):
                             lowerCamelCase__        =				0
                             lowerCamelCase__        =				1
                             lowerCamelCase__        =				0
                             lowerCamelCase__        =				1
                       lowerCamelCase__        =				pt_model_class(A__			).eval()
                       # Flax models don't use the `use_cache` option and cache is not returned as a default.
                       # So we disable `use_cache` here for PyTorch model.
                       lowerCamelCase__        =				False
                       lowerCamelCase__        =				model_class(A__	,  dtype=jnp.floataa			)
                       lowerCamelCase__        =				convert_pytorch_state_dict_to_flax(pt_model.state_dict()	,  A__			)
                       lowerCamelCase__        =				fx_state

                       with torch.no_grad():
                             lowerCamelCase__        =				pt_model(**A__			).to_tuple()

                       lowerCamelCase__        =				fx_model(**A__			).to_tuple()
                       self.assertEqual(len(A__			)	,  len(A__			)	,  'Output lengths differ between Flax and PyTorch'			)
                       for fx_output, pt_output in zip(A__	,  A__			):
                             self.assert_almost_equals(fx_output[:, -1]	,  pt_output[:, -1].numpy()	,  4E-2			)

                       with tempfile.TemporaryDirectory() as tmpdirname:
                             pt_model.save_pretrained(A__			)
                             lowerCamelCase__        =				model_class.from_pretrained(A__	,  from_pt=A__			)

                       lowerCamelCase__        =				fx_model_loaded(**A__			).to_tuple()
                       self.assertEqual(
                           len(A__			)	,  len(A__			)	,  'Output lengths differ between Flax and PyTorch'			)
                       for fx_output_loaded, pt_output in zip(A__	,  A__			):
                             self.assert_almost_equals(fx_output_loaded[:, -1]	,  pt_output[:, -1].numpy()	,  4E-2			)




     @is_pt_flax_cross_test
     def  __snake_case   (    self  :   Optional[Any]			)				->       Dict:
           lowerCamelCase__  ,		lowerCamelCase__        =				self.model_tester.prepare_config_and_inputs_for_common()
           for model_class in self.all_model_classes:
                 with self.subTest(model_class.__name__			):
                       # prepare inputs
                       lowerCamelCase__        =				self._prepare_for_class(A__	,  A__			)
                       lowerCamelCase__        =				{k: torch.tensor(v.tolist()			) for k, v in prepared_inputs_dict.items()}

                       # load corresponding PyTorch class
                       lowerCamelCase__        =				model_class.__name__[4:]  # Skip the "Flax" at the beginning
                       lowerCamelCase__        =				getattr(A__	,  A__			)

                       lowerCamelCase__        =				pt_model_class(A__			).eval()
                       lowerCamelCase__        =				False
                       lowerCamelCase__        =				model_class(A__	,  dtype=jnp.floataa			)

                       lowerCamelCase__        =				load_flax_weights_in_pytorch_model(A__	,  fx_model.params			)
                       lowerCamelCase__  ,		lowerCamelCase__        =				pt_inputs['input_ids'].shape
                       lowerCamelCase__        =				np.random.randint(0	,  seq_length - 1	,  size=(batch_size,)			)
                       for batch_idx, start_index in enumerate(A__			):
                             lowerCamelCase__        =				0
                             lowerCamelCase__        =				1
                             lowerCamelCase__        =				0
                             lowerCamelCase__        =				1

                       # make sure weights are tied in PyTorch
                       pt_model.tie_weights()

                       with torch.no_grad():
                             lowerCamelCase__        =				pt_model(**A__			).to_tuple()

                       lowerCamelCase__        =				fx_model(**A__			).to_tuple()
                       self.assertEqual(len(A__			)	,  len(A__			)	,  'Output lengths differ between Flax and PyTorch'			)
                       for fx_output, pt_output in zip(A__	,  A__			):
                             self.assert_almost_equals(fx_output[:, -1]	,  pt_output[:, -1].numpy()	,  4E-2			)

                       with tempfile.TemporaryDirectory() as tmpdirname:
                             fx_model.save_pretrained(A__			)
                             lowerCamelCase__        =				pt_model_class.from_pretrained(A__	,  from_flax=A__			)

                       with torch.no_grad():
                             lowerCamelCase__        =				pt_model_loaded(**A__			).to_tuple()

                       self.assertEqual(
                           len(A__			)	,  len(A__			)	,  'Output lengths differ between Flax and PyTorch'			)
                       for fx_output, pt_output in zip(A__	,  A__			):
                             self.assert_almost_equals(fx_output[:, -1]	,  pt_output[:, -1].numpy()	,  4E-2			)




     @slow
     def  __snake_case   (    self  :   Union[str, Any]			)				->       Any:
           for model_class_name in self.all_model_classes:
                 lowerCamelCase__        =				model_class_name.from_pretrained('facebook/xglm-564M'			)
                 lowerCamelCase__        =				model(np.ones((1, 1)			)			)
                 self.assertIsNotNone(A__			)





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 (
    get_resize_output_image_size,
    normalize,
    pad,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging
from ...utils.import_utils import is_vision_available


__SCREAMING_SNAKE_CASE    :   Tuple       =logging.get_logger(__name__)


if is_vision_available():
      import PIL






class 			A			(		_lowerCAmelCase		):
     """simple docstring"""

     _snake_case:	Dict     =["pixel_values"]




     def __init__(    self  :   Optional[Any]	,  A__  :   bool = True	,  A__  :   Dict[str, int] = None	,  A__  :   PILImageResampling = PILImageResampling.BILINEAR	,  A__  :   bool = True	,  A__  :   bool = False	,  A__  :   bool = True	,  A__  :   bool = True	,  A__  :   Union[int, float] = 1 / 2_5_5	,  A__  :   bool = True	,  A__  :   Optional[Union[float, List[float]]] = None	,  A__  :   Optional[Union[float, List[float]]] = None	,  **A__  :   List[str]	,  )				->       None:
           super().__init__(**A__			)

           lowerCamelCase__        =				size if size is not None else {'height': 2_5_6_0, 'width': 1_9_2_0}
           if isinstance(A__	,  (tuple, list)			):
                 # The previous feature extractor size parameter was in (width, height) format
                 lowerCamelCase__        =				size[::-1]
           lowerCamelCase__        =				get_size_dict(A__			)

           lowerCamelCase__        =				do_resize
           lowerCamelCase__        =				size
           lowerCamelCase__        =				resample
           lowerCamelCase__        =				do_thumbnail
           lowerCamelCase__        =				do_align_long_axis
           lowerCamelCase__        =				do_pad
           lowerCamelCase__        =				do_rescale
           lowerCamelCase__        =				rescale_factor
           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




     def  __snake_case   (    self  :   str	,  A__  :   np.ndarray	,  A__  :   Dict[str, int]	,  A__  :   Optional[Union[str, ChannelDimension]] = None			)				->       np.ndarray:
           lowerCamelCase__  ,		lowerCamelCase__        =				get_image_size(A__			)
           lowerCamelCase__  ,		lowerCamelCase__        =				size['height'], size['width']

           if (output_width < output_height and input_width > input_height) or (
               output_width > output_height and input_width < input_height
           ):
                 lowerCamelCase__        =				np.rotaa(A__	,  3			)

           if data_format is not None:
                 lowerCamelCase__        =				to_channel_dimension_format(A__	,  A__			)

           return image




     def  __snake_case   (    self  :   Tuple	,  A__  :   np.ndarray	,  A__  :   Dict[str, int]	,  A__  :   bool = False	,  A__  :   Optional[Union[str, ChannelDimension]] = None	,  )				->       np.ndarray:
           lowerCamelCase__  ,		lowerCamelCase__        =				size['height'], size['width']
           lowerCamelCase__  ,		lowerCamelCase__        =				get_image_size(A__			)

           lowerCamelCase__        =				output_width - input_width
           lowerCamelCase__        =				output_height - input_height

           if random_padding:
                 lowerCamelCase__        =				np.random.randint(low=0	,  high=delta_height + 1			)
                 lowerCamelCase__        =				np.random.randint(low=0	,  high=delta_width + 1			)
           else:
                 lowerCamelCase__        =				delta_height // 2
                 lowerCamelCase__        =				delta_width // 2

           lowerCamelCase__        =				delta_height - pad_top
           lowerCamelCase__        =				delta_width - pad_left

           lowerCamelCase__        =				((pad_top, pad_bottom), (pad_left, pad_right))
           return pad(A__	,  A__	,  data_format=A__			)




     def  __snake_case   (    self  :   int	,  *A__  :   Tuple	,  **A__  :   Dict			)				->       List[Any]:
           logger.info('pad is deprecated and will be removed in version 4.27. Please use pad_image instead.'			)
           return self.pad_image(*A__	,  **A__			)




     def  __snake_case   (    self  :   Any	,  A__  :   np.ndarray	,  A__  :   Dict[str, int]	,  A__  :   PILImageResampling = PILImageResampling.BICUBIC	,  A__  :   Optional[Union[str, ChannelDimension]] = None	,  **A__  :   Any	,  )				->       np.ndarray:
           lowerCamelCase__  ,		lowerCamelCase__        =				get_image_size(A__			)
           lowerCamelCase__  ,		lowerCamelCase__        =				size['height'], size['width']

           # We always resize to the smallest of either the input or output size.
           lowerCamelCase__        =				min(A__	,  A__			)
           lowerCamelCase__        =				min(A__	,  A__			)

           if height == input_height and width == input_width:
                 return image

           if input_height > input_width:
                 lowerCamelCase__        =				int(input_width * height / input_height			)
           elif input_width > input_height:
                 lowerCamelCase__        =				int(input_height * width / input_width			)

           return resize(
               A__	,  size=(height, width)	,  resample=A__	,  reducing_gap=2.0	,  data_format=A__	,  **A__			)




     def  __snake_case   (    self  :   List[str]	,  A__  :   np.ndarray	,  A__  :   Dict[str, int]	,  A__  :   PILImageResampling = PILImageResampling.BICUBIC	,  A__  :   Optional[Union[str, ChannelDimension]] = None	,  **A__  :   Any	,  )				->       np.ndarray:
           lowerCamelCase__        =				get_size_dict(A__			)
           lowerCamelCase__        =				min(size['height']	,  size['width']			)
           lowerCamelCase__        =				get_resize_output_image_size(A__	,  size=A__	,  default_to_square=A__			)
           lowerCamelCase__        =				resize(A__	,  size=A__	,  resample=A__	,  data_format=A__	,  **A__			)
           return resized_image




     def  __snake_case   (    self  :   Optional[int]	,  A__  :   np.ndarray	,  A__  :   Union[int, float]	,  A__  :   Optional[Union[str, ChannelDimension]] = None	,  **A__  :   Optional[int]	,  )				->       Tuple:
           return rescale(A__	,  scale=A__	,  data_format=A__	,  **A__			)




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




     def  __snake_case   (    self  :   Union[str, Any]	,  A__  :   ImageInput	,  A__  :   bool = None	,  A__  :   Dict[str, int] = None	,  A__  :   PILImageResampling = None	,  A__  :   bool = None	,  A__  :   bool = None	,  A__  :   bool = None	,  A__  :   bool = False	,  A__  :   bool = None	,  A__  :   float = None	,  A__  :   bool = None	,  A__  :   Optional[Union[float, List[float]]] = None	,  A__  :   Optional[Union[float, List[float]]] = None	,  A__  :   Optional[Union[str, TensorType]] = None	,  A__  :   Optional[ChannelDimension] = ChannelDimension.FIRST	,  **A__  :   Any	,  )				->       PIL.Image.Image:
           lowerCamelCase__        =				do_resize if do_resize is not None else self.do_resize
           lowerCamelCase__        =				size if size is not None else self.size
           if isinstance(A__	,  (tuple, list)			):
                 # Previous feature extractor had size in (width, height) format
                 lowerCamelCase__        =				size[::-1]
           lowerCamelCase__        =				get_size_dict(A__			)
           lowerCamelCase__        =				resample if resample is not None else self.resample
           lowerCamelCase__        =				do_thumbnail if do_thumbnail is not None else self.do_thumbnail
           lowerCamelCase__        =				do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
           lowerCamelCase__        =				do_pad if do_pad is not None else self.do_pad
           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__        =				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__        =				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_rescale and rescale_factor is None:
                 raise ValueError('Rescale factor must be specified if do_rescale is True.'			)

           if do_pad and size is None:
                 raise ValueError('Size must be specified if do_pad 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(A__			) for image in images]

           if do_align_long_axis:
                 lowerCamelCase__        =				[self.align_long_axis(A__	,  size=A__			) for image in images]

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

           if do_thumbnail:
                 lowerCamelCase__        =				[self.thumbnail(image=A__	,  size=A__			) for image in images]

           if do_pad:
                 lowerCamelCase__        =				[self.pad_image(image=A__	,  size=A__	,  random_padding=A__			) for image in images]

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

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

           lowerCamelCase__        =				[to_channel_dimension_format(A__	,  A__			) for image in images]

           lowerCamelCase__        =				{'pixel_values': images}
           return BatchFeature(data=A__	,  tensor_type=A__			)