


import unittest

from parameterized import parameterized

from transformers import OpenLlamaConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import OpenLlamaForCausalLM, OpenLlamaForSequenceClassification, OpenLlamaModel







class        UpperCamelCase__   :

					def __init__(     self       :   List[str]							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   List[str]=13							,					UpperCamelCase__       :   str=7							,					UpperCamelCase__       :   List[str]=True							,					UpperCamelCase__       :   List[str]=True							,					UpperCamelCase__       :   str=False							,					UpperCamelCase__       :   str=True							,					UpperCamelCase__       :   Union[str, Any]=99							,					UpperCamelCase__       :   Dict=32							,					UpperCamelCase__       :   Union[str, Any]=5							,					UpperCamelCase__       :   Tuple=4							,					UpperCamelCase__       :   Dict=37							,					UpperCamelCase__       :   Any="gelu"							,					UpperCamelCase__       :   Dict=0.1							,					UpperCamelCase__       :   Tuple=0.1							,					UpperCamelCase__       :   Tuple=512							,					UpperCamelCase__       :   Union[str, Any]=16							,					UpperCamelCase__       :   List[str]=2							,					UpperCamelCase__       :   int=0.02							,					UpperCamelCase__       :   int=3							,					UpperCamelCase__       :   Optional[Any]=4							,					UpperCamelCase__       :   int=None							,					):






										'''simple docstring'''






										lowercase_  							=			parent
										lowercase_  							=			batch_size
										lowercase_  							=			seq_length
										lowercase_  							=			is_training
										lowercase_  							=			use_input_mask
										lowercase_  							=			use_token_type_ids
										lowercase_  							=			use_labels
										lowercase_  							=			vocab_size
										lowercase_  							=			hidden_size
										lowercase_  							=			num_hidden_layers
										lowercase_  							=			num_attention_heads
										lowercase_  							=			intermediate_size
										lowercase_  							=			hidden_act
										lowercase_  							=			hidden_dropout_prob
										lowercase_  							=			attention_probs_dropout_prob
										lowercase_  							=			max_position_embeddings
										lowercase_  							=			type_vocab_size
										lowercase_  							=			type_sequence_label_size
										lowercase_  							=			initializer_range
										lowercase_  							=			num_labels
										lowercase_  							=			num_choices
										lowercase_  							=			scope

					def   UpperCAmelCase__       (     self       :   Optional[Any]       ):






										'''simple docstring'''






										lowercase_  							=			ids_tensor([self.batch_size, self.seq_length]							,					self.vocab_size       )

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

										lowercase_  							=			None
										if self.use_token_type_ids:
															lowercase_  							=			ids_tensor([self.batch_size, self.seq_length]							,					self.type_vocab_size       )

										lowercase_  							=			None
										lowercase_  							=			None
										lowercase_  							=			None
										if self.use_labels:
															lowercase_  							=			ids_tensor([self.batch_size]							,					self.type_sequence_label_size       )
															lowercase_  							=			ids_tensor([self.batch_size, self.seq_length]							,					self.num_labels       )
															lowercase_  							=			ids_tensor([self.batch_size]							,					self.num_choices       )

										lowercase_  							=			self.get_config()

										return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

					def   UpperCAmelCase__       (     self       :   Dict       ):






										'''simple docstring'''






										return OpenLlamaConfig(
										    vocab_size=self.vocab_size							,					hidden_size=self.hidden_size							,					num_hidden_layers=self.num_hidden_layers							,					num_attention_heads=self.num_attention_heads							,					intermediate_size=self.intermediate_size							,					hidden_act=self.hidden_act							,					hidden_dropout_prob=self.hidden_dropout_prob							,					attention_probs_dropout_prob=self.attention_probs_dropout_prob							,					max_position_embeddings=self.max_position_embeddings							,					type_vocab_size=self.type_vocab_size							,					is_decoder=UpperCamelCase__							,					initializer_range=self.initializer_range							,					use_stable_embedding=UpperCamelCase__							,					)

					def   UpperCAmelCase__       (     self       :   str							,					UpperCamelCase__       :   Optional[Any]							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   Dict							,					UpperCamelCase__       :   List[str]							,					UpperCamelCase__       :   Dict							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   Optional[Any]       ):






										'''simple docstring'''






										lowercase_  							=			OpenLlamaModel(config=UpperCamelCase__       )
										model.to(UpperCamelCase__       )
										model.eval()
										lowercase_  							=			model(UpperCamelCase__							,					attention_mask=UpperCamelCase__       )
										lowercase_  							=			model(UpperCamelCase__       )
										self.parent.assertEqual(result.last_hidden_state.shape							,					(self.batch_size, self.seq_length, self.hidden_size)       )

					def   UpperCAmelCase__       (     self       :   Union[str, Any]							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   Optional[int]							,					UpperCamelCase__       :   Optional[Any]							,					UpperCamelCase__       :   Optional[Any]							,					):






										'''simple docstring'''






										lowercase_  							=			True
										lowercase_  							=			OpenLlamaModel(UpperCamelCase__       )
										model.to(UpperCamelCase__       )
										model.eval()
										lowercase_  							=			model(
										    UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					encoder_hidden_states=UpperCamelCase__							,					encoder_attention_mask=UpperCamelCase__							,					)
										lowercase_  							=			model(
										    UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					encoder_hidden_states=UpperCamelCase__							,					)
										lowercase_  							=			model(UpperCamelCase__							,					attention_mask=UpperCamelCase__       )
										self.parent.assertEqual(result.last_hidden_state.shape							,					(self.batch_size, self.seq_length, self.hidden_size)       )

					def   UpperCAmelCase__       (     self       :   Any							,					UpperCamelCase__       :   List[str]							,					UpperCamelCase__       :   List[Any]							,					UpperCamelCase__       :   Optional[int]							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   Any							,					UpperCamelCase__       :   Union[str, Any]							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   Any							,					UpperCamelCase__       :   List[Any]							,					):






										'''simple docstring'''






										lowercase_  							=			OpenLlamaForCausalLM(config=UpperCamelCase__       )
										model.to(UpperCamelCase__       )
										model.eval()
										lowercase_  							=			model(UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					labels=UpperCamelCase__       )
										self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.seq_length, self.vocab_size)       )

					def   UpperCAmelCase__       (     self       :   int							,					UpperCamelCase__       :   Optional[int]							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   Optional[Any]							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   List[str]							,					UpperCamelCase__       :   int							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   Tuple							,					):






										'''simple docstring'''






										lowercase_  							=			True
										lowercase_  							=			True
										lowercase_  							=			OpenLlamaForCausalLM(config=UpperCamelCase__       )
										model.to(UpperCamelCase__       )
										model.eval()

										# first forward pass
										lowercase_  							=			model(
										    UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					encoder_hidden_states=UpperCamelCase__							,					encoder_attention_mask=UpperCamelCase__							,					use_cache=UpperCamelCase__							,					)
										lowercase_  							=			outputs.past_key_values

										# create hypothetical multiple next token and extent to next_input_ids
										lowercase_  							=			ids_tensor((self.batch_size, 3)							,					config.vocab_size       )
										lowercase_  							=			ids_tensor((self.batch_size, 3)							,					vocab_size=2       )

										# append to next input_ids and
										lowercase_  							=			torch.cat([input_ids, next_tokens]							,					dim=-1       )
										lowercase_  							=			torch.cat([input_mask, next_mask]							,					dim=-1       )

										lowercase_  							=			model(
										    UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					encoder_hidden_states=UpperCamelCase__							,					encoder_attention_mask=UpperCamelCase__							,					output_hidden_states=UpperCamelCase__							,					)["""hidden_states"""][0]
										lowercase_  							=			model(
										    UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					encoder_hidden_states=UpperCamelCase__							,					encoder_attention_mask=UpperCamelCase__							,					past_key_values=UpperCamelCase__							,					output_hidden_states=UpperCamelCase__							,					)["""hidden_states"""][0]

										# select random slice
										lowercase_  							=			ids_tensor((1,)							,					output_from_past.shape[-1]       ).item()
										lowercase_  							=			output_from_no_past[:, -3:, random_slice_idx].detach()
										lowercase_  							=			output_from_past[:, :, random_slice_idx].detach()

										self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]       )

										# test that outputs are equal for slice
										self.parent.assertTrue(torch.allclose(UpperCamelCase__							,					UpperCamelCase__							,					atol=1e-3       )       )







					def   UpperCAmelCase__       (     self       :   Optional[Any]       ):






										'''simple docstring'''






										lowercase_  							=			self.prepare_config_and_inputs()
										(
										    (
										    lowercase_
										)							,					(
										    lowercase_
										)							,					(
										    lowercase_
										)							,					(
										    lowercase_
										)							,					(
										    lowercase_
										)							,					(
										    lowercase_
										)							,					(
										    lowercase_
										)							,					
										)  							=			config_and_inputs
										lowercase_  							=			{"""input_ids""": input_ids, """attention_mask""": input_mask}
										return config, inputs_dict







@require_torch
class        UpperCamelCase__   (	__magic_name__							,				__magic_name__							,				__magic_name__							,				unittest.TestCase   ):
					__SCREAMING_SNAKE_CASE       :  Union[str, Any]						=   (
					    (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else ()
					)
					__SCREAMING_SNAKE_CASE       :  List[str]						=   (OpenLlamaForCausalLM,) if is_torch_available() else ()
					__SCREAMING_SNAKE_CASE       :  List[Any]						=   (
					    {
					        'feature-extraction': OpenLlamaModel,
					        'text-classification': OpenLlamaForSequenceClassification,
					        'text-generation': OpenLlamaForCausalLM,
					        'zero-shot': OpenLlamaForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					__SCREAMING_SNAKE_CASE       :  Tuple						=   False
					__SCREAMING_SNAKE_CASE       :  Optional[int]						=   False

					def   UpperCAmelCase__       (     self       :   List[Any]       ):






										'''simple docstring'''






										lowercase_  							=			OpenLlamaModelTester(self       )
										lowercase_  							=			ConfigTester(self							,					config_class=UpperCamelCase__							,					hidden_size=37       )

					def   UpperCAmelCase__       (     self       :   Optional[Any]       ):






										'''simple docstring'''






										self.config_tester.run_common_tests()

					def   UpperCAmelCase__       (     self       :   str       ):






										'''simple docstring'''






										lowercase_  							=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   Dict       ):






										'''simple docstring'''






										lowercase_  							=			self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
															lowercase_  							=			type
															self.model_tester.create_and_check_model(*UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   List[Any]       ):






										'''simple docstring'''






										lowercase_							,					lowercase_  							=			self.model_tester.prepare_config_and_inputs_for_common()
										lowercase_  							=			3
										lowercase_  							=			input_dict["""input_ids"""]
										lowercase_  							=			input_ids.ne(1       ).to(UpperCamelCase__       )
										lowercase_  							=			ids_tensor([self.model_tester.batch_size]							,					self.model_tester.type_sequence_label_size       )
										lowercase_  							=			OpenLlamaForSequenceClassification(UpperCamelCase__       )
										model.to(UpperCamelCase__       )
										model.eval()
										lowercase_  							=			model(UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					labels=UpperCamelCase__       )
										self.assertEqual(result.logits.shape							,					(self.model_tester.batch_size, self.model_tester.num_labels)       )

					def   UpperCAmelCase__       (     self       :   Union[str, Any]       ):






										'''simple docstring'''






										lowercase_							,					lowercase_  							=			self.model_tester.prepare_config_and_inputs_for_common()
										lowercase_  							=			3
										lowercase_  							=			"""single_label_classification"""
										lowercase_  							=			input_dict["""input_ids"""]
										lowercase_  							=			input_ids.ne(1       ).to(UpperCamelCase__       )
										lowercase_  							=			ids_tensor([self.model_tester.batch_size]							,					self.model_tester.type_sequence_label_size       )
										lowercase_  							=			OpenLlamaForSequenceClassification(UpperCamelCase__       )
										model.to(UpperCamelCase__       )
										model.eval()
										lowercase_  							=			model(UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					labels=UpperCamelCase__       )
										self.assertEqual(result.logits.shape							,					(self.model_tester.batch_size, self.model_tester.num_labels)       )

					def   UpperCAmelCase__       (     self       :   Dict       ):






										'''simple docstring'''






										lowercase_							,					lowercase_  							=			self.model_tester.prepare_config_and_inputs_for_common()
										lowercase_  							=			3
										lowercase_  							=			"""multi_label_classification"""
										lowercase_  							=			input_dict["""input_ids"""]
										lowercase_  							=			input_ids.ne(1       ).to(UpperCamelCase__       )
										lowercase_  							=			ids_tensor(
										    [self.model_tester.batch_size, config.num_labels]							,					self.model_tester.type_sequence_label_size       ).to(torch.float       )
										lowercase_  							=			OpenLlamaForSequenceClassification(UpperCamelCase__       )
										model.to(UpperCamelCase__       )
										model.eval()
										lowercase_  							=			model(UpperCamelCase__							,					attention_mask=UpperCamelCase__							,					labels=UpperCamelCase__       )
										self.assertEqual(result.logits.shape							,					(self.model_tester.batch_size, self.model_tester.num_labels)       )

					@unittest.skip("""Open-Llama buffers include complex numbers, which breaks this test"""       )
					def   UpperCAmelCase__       (     self       :   Dict       ):






										'''simple docstring'''






										pass







					@parameterized.expand([("""linear""",), ("""dynamic""",)]       )
					def   UpperCAmelCase__       (     self       :   Tuple							,					UpperCamelCase__       :   Union[str, Any]       ):






										'''simple docstring'''






										lowercase_							,					lowercase_  							=			self.model_tester.prepare_config_and_inputs_for_common()
										lowercase_  							=			ids_tensor([1, 10]							,					config.vocab_size       )
										lowercase_  							=			ids_tensor([1, int(config.max_position_embeddings * 1.5       )]							,					config.vocab_size       )

										set_seed(42       )  # Fixed seed at init time so the two models get the same random weights
										lowercase_  							=			OpenLlamaModel(UpperCamelCase__       )
										original_model.to(UpperCamelCase__       )
										original_model.eval()
										lowercase_  							=			original_model(UpperCamelCase__       ).last_hidden_state
										lowercase_  							=			original_model(UpperCamelCase__       ).last_hidden_state

										set_seed(42       )  # Fixed seed at init time so the two models get the same random weights
										lowercase_  							=			{"""type""": scaling_type, """factor""": 10.0}
										lowercase_  							=			OpenLlamaModel(UpperCamelCase__       )
										scaled_model.to(UpperCamelCase__       )
										scaled_model.eval()
										lowercase_  							=			scaled_model(UpperCamelCase__       ).last_hidden_state
										lowercase_  							=			scaled_model(UpperCamelCase__       ).last_hidden_state

										# Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
										# maximum sequence length, so the outputs for the short input should match.
										if scaling_type == "dynamic":
															self.assertTrue(torch.allclose(UpperCamelCase__							,					UpperCamelCase__							,					atol=1e-5       )       )
										else:
															self.assertFalse(torch.allclose(UpperCamelCase__							,					UpperCamelCase__							,					atol=1e-5       )       )

										# The output should be different for long inputs
										self.assertFalse(torch.allclose(UpperCamelCase__							,					UpperCamelCase__							,					atol=1e-5       )       )






from typing import Dict, Iterable, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


a					  =     logging.get_logger(__name__)







class        UpperCamelCase__   (	__magic_name__   ):
					__SCREAMING_SNAKE_CASE       :  List[Any]						=   ['pixel_values']

					def __init__(     self       :   List[str]							,					UpperCamelCase__       :   bool = True							,					UpperCamelCase__       :   Dict[str, int] = None							,					UpperCamelCase__       :   PILImageResampling = PILImageResampling.BICUBIC							,					UpperCamelCase__       :   bool = True							,					UpperCamelCase__       :   Dict[str, int] = None							,					UpperCamelCase__       :   bool = True							,					UpperCamelCase__       :   Union[int, float] = 1 / 255							,					UpperCamelCase__       :   bool = True							,					UpperCamelCase__       :   Optional[Union[float, Iterable[float]]] = IMAGENET_DEFAULT_MEAN							,					UpperCamelCase__       :   Optional[Union[float, Iterable[float]]] = IMAGENET_DEFAULT_STD							,					**UpperCamelCase__       :   Dict							,					):






										'''simple docstring'''






										super().__init__(**UpperCamelCase__       )
										lowercase_  							=			size if size is not None else {"""shortest_edge""": 224}
										lowercase_  							=			get_size_dict(UpperCamelCase__							,					default_to_square=UpperCamelCase__       )
										lowercase_  							=			crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
										lowercase_  							=			get_size_dict(UpperCamelCase__							,					param_name="""crop_size"""       )

										lowercase_  							=			do_resize
										lowercase_  							=			size
										lowercase_  							=			resample
										lowercase_  							=			do_center_crop
										lowercase_  							=			crop_size
										lowercase_  							=			do_rescale
										lowercase_  							=			rescale_factor
										lowercase_  							=			do_normalize
										lowercase_  							=			image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
										lowercase_  							=			image_std if image_std is not None else IMAGENET_DEFAULT_STD

					def   UpperCAmelCase__       (     self       :   int							,					UpperCamelCase__       :   np.ndarray							,					UpperCamelCase__       :   Dict[str, int]							,					UpperCamelCase__       :   PILImageResampling = PILImageResampling.BICUBIC							,					UpperCamelCase__       :   Optional[Union[str, ChannelDimension]] = None							,					**UpperCamelCase__       :   Optional[int]							,					):






										'''simple docstring'''






										lowercase_  							=			get_size_dict(UpperCamelCase__							,					default_to_square=UpperCamelCase__       )
										# size_dict is a dict with either keys "height" and "width" or "shortest_edge"
										if "shortest_edge" in size:
															lowercase_  							=			int((256 / 224) * size["""shortest_edge"""]       )
															lowercase_  							=			get_resize_output_image_size(UpperCamelCase__							,					size=UpperCamelCase__							,					default_to_square=UpperCamelCase__       )
															lowercase_  							=			{"""height""": output_size[0], """width""": output_size[1]}
										if "height" not in size_dict or "width" not in size_dict:
															raise ValueError(
															    F'''Size dict must have keys \'height\' and \'width\' or \'shortest_edge\'. Got {size_dict.keys()}'''       )
										return resize(
										    UpperCamelCase__							,					size=(size_dict["""height"""], size_dict["""width"""])							,					resample=UpperCamelCase__							,					data_format=UpperCamelCase__							,					**UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   str							,					UpperCamelCase__       :   np.ndarray							,					UpperCamelCase__       :   Dict[str, int]							,					UpperCamelCase__       :   Optional[Union[str, ChannelDimension]] = None							,					**UpperCamelCase__       :   str							,					):






										'''simple docstring'''






										lowercase_  							=			get_size_dict(UpperCamelCase__       )
										if "height" not in size or "width" not in size:
															raise ValueError(F'''Size dict must have keys \'height\' and \'width\'. Got {size.keys()}'''       )
										return center_crop(UpperCamelCase__							,					size=(size["""height"""], size["""width"""])							,					data_format=UpperCamelCase__							,					**UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   Optional[int]							,					UpperCamelCase__       :   np.ndarray							,					UpperCamelCase__       :   Union[int, float]							,					UpperCamelCase__       :   Optional[Union[str, ChannelDimension]] = None							,					**UpperCamelCase__       :   str							,					):






										'''simple docstring'''






										return rescale(UpperCamelCase__							,					scale=UpperCamelCase__							,					data_format=UpperCamelCase__							,					**UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   List[str]							,					UpperCamelCase__       :   np.ndarray							,					UpperCamelCase__       :   Union[float, List[float]]							,					UpperCamelCase__       :   Union[float, List[float]]							,					UpperCamelCase__       :   Optional[Union[str, ChannelDimension]] = None							,					**UpperCamelCase__       :   Optional[int]							,					):






										'''simple docstring'''






										return normalize(UpperCamelCase__							,					mean=UpperCamelCase__							,					std=UpperCamelCase__							,					data_format=UpperCamelCase__							,					**UpperCamelCase__       )







					def   UpperCAmelCase__       (     self       :   Dict							,					UpperCamelCase__       :   ImageInput							,					UpperCamelCase__       :   Optional[bool] = None							,					UpperCamelCase__       :   Optional[Dict[str, int]] = None							,					UpperCamelCase__       :   PILImageResampling = None							,					UpperCamelCase__       :   Optional[bool] = None							,					UpperCamelCase__       :   Optional[Dict[str, int]] = None							,					UpperCamelCase__       :   Optional[bool] = None							,					UpperCamelCase__       :   Optional[float] = None							,					UpperCamelCase__       :   Optional[bool] = None							,					UpperCamelCase__       :   Optional[Union[float, Iterable[float]]] = None							,					UpperCamelCase__       :   Optional[Union[float, Iterable[float]]] = None							,					UpperCamelCase__       :   Optional[TensorType] = None							,					UpperCamelCase__       :   ChannelDimension = ChannelDimension.FIRST							,					**UpperCamelCase__       :   Optional[int]							,					):






										'''simple docstring'''






										lowercase_  							=			do_resize if do_resize is not None else self.do_resize
										lowercase_  							=			resample if resample is not None else self.resample
										lowercase_  							=			do_center_crop if do_center_crop is not None else self.do_center_crop
										lowercase_  							=			do_rescale if do_rescale is not None else self.do_rescale
										lowercase_  							=			rescale_factor if rescale_factor is not None else self.rescale_factor
										lowercase_  							=			do_normalize if do_normalize is not None else self.do_normalize
										lowercase_  							=			image_mean if image_mean is not None else self.image_mean
										lowercase_  							=			image_std if image_std is not None else self.image_std

										lowercase_  							=			size if size is not None else self.size
										lowercase_  							=			get_size_dict(UpperCamelCase__							,					default_to_square=UpperCamelCase__       )
										lowercase_  							=			crop_size if crop_size is not None else self.crop_size
										lowercase_  							=			get_size_dict(UpperCamelCase__							,					param_name="""crop_size"""       )

										lowercase_  							=			make_list_of_images(UpperCamelCase__       )

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

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

										if do_resize:
															lowercase_  							=			[self.resize(UpperCamelCase__							,					UpperCamelCase__							,					UpperCamelCase__       ) for image in images]

										if do_center_crop:
															lowercase_  							=			[self.center_crop(UpperCamelCase__							,					UpperCamelCase__       ) for image in images]

										if do_rescale:
															lowercase_  							=			[self.rescale(UpperCamelCase__							,					UpperCamelCase__       ) for image in images]

										if do_normalize:
															lowercase_  							=			[self.normalize(UpperCamelCase__							,					UpperCamelCase__							,					UpperCamelCase__       ) for image in images]

										lowercase_  							=			[to_channel_dimension_format(UpperCamelCase__							,					UpperCamelCase__       ) for image in images]

										lowercase_  							=			{"""pixel_values""": images}
										return BatchFeature(data=UpperCamelCase__							,					tensor_type=UpperCamelCase__       )


