





from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
				import tensorflow as tf

				from transformers import (
				    AutoTokenizer,
				    TFAutoModelForCausalLM,
				    TFAutoModelForSeqaSeqLM,
				    TFAutoModelForSpeechSeqaSeq,
				    TFAutoModelForVisionaSeq,
				    TFBartForConditionalGeneration,
				    TFLogitsProcessorList,
				    TFMinLengthLogitsProcessor,
				    tf_top_k_top_p_filtering,
				)

if is_tensorflow_text_available():
				import tensorflow_text as text



@require_tf
class    _a     (				unittest.TestCase							):






							"""simple docstring"""

							def      A_  (      self				:     List[str]    )	->Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :				List[str]   =					tf.convert_to_tensor(
													    [
													        [
													            8.222_0991,  # 3rd highest value; idx. 0
													            -0.562_0044,
													            5.2322_9752,
													            4.038_6393,
													            -6.879_8378,
													            -0.5478_5802,
													            -3.201_2153,
													            2.9277_7176,
													            1.8817_1953,
													            7.3534_1276,  # 5th highest value; idx. 9
													            8.4320_7833,  # 2nd highest value; idx. 10
													            -9.8571_1836,
													            -5.9620_9236,
													            -1.1303_9161,
													            -7.111_5294,
													            -0.836_9633,
													            -5.318_6408,
													            7.0642_7407,
													            0.8136_9344,
													            -0.8202_3817,
													            -5.917_9796,
													            0.5881_3443,
													            -6.9977_8438,
													            4.7155_1189,
													            -0.1877_1637,
													            7.4402_0759,  # 4th highest value; idx. 25
													            9.3845_0987,  # 1st highest value; idx. 26
													            2.1266_2941,
													            -9.3256_2038,
													            2.3565_2522,
													        ],  # cummulative prob of 5 highest values <= 0.6
													        [
													            0.5842_5518,
													            4.5313_9238,
													            -5.5751_0464,
													            -6.2803_0699,
													            -7.1952_9503,
													            -4.0212_2551,
													            1.3933_7037,
													            -6.0670_7057,
													            1.5948_0517,
													            -9.64_3119,
													            0.0390_7799,
													            0.6723_1762,
													            -8.8820_6726,
													            6.2711_5922,  # 4th highest value; idx. 13
													            2.2852_0723,
													            4.8276_7506,
													            4.3042_1368,
													            8.827_5313,  # 2nd highest value; idx. 17
													            5.4402_9958,  # 5th highest value; idx. 18
													            -4.473_5794,
													            7.3857_9536,  # 3rd highest value; idx. 20
													            -2.9105_1663,
													            2.6194_6077,
													            -2.567_4762,
													            -9.4895_9302,
													            -4.0292_2645,
													            -1.3541_6918,
													            9.6770_2323,  # 1st highest value; idx. 27
													            -5.8947_8553,
													            1.8537_0467,
													        ],  # cummulative prob of 5 highest values <= 0.6
													    ]							,	dtype=tf.floataa							,	)

													SCREAMING_SNAKE_CASE__     :				List[str]   =					tf.convert_to_tensor(
													    [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]							,	dtype=tf.intaa							,	)  # expected non filtered idx as noted above

													SCREAMING_SNAKE_CASE__     :				Any   =					tf.convert_to_tensor(
													    [8.22_2099, 7.353_4126, 8.43_2078, 7.440_2075, 9.3_8451, 6.27_1159, 8.82_7531, 5.440_2995, 7.385_7956, 9.67_7023]							,	dtype=tf.floataa							,	)  # expected non filtered values as noted above

													SCREAMING_SNAKE_CASE__     :				Tuple   =					tf_top_k_top_p_filtering(a							,	top_k=10							,	top_p=0.6							,	min_tokens_to_keep=4    )

													SCREAMING_SNAKE_CASE__     :				Tuple   =					output[output != -float("inf"    )]
													SCREAMING_SNAKE_CASE__     :				Dict   =					tf.cast(
													    tf.where(tf.not_equal(a							,	tf.constant(-float("inf"    )							,	dtype=tf.floataa    )    )    )							,	dtype=tf.intaa							,	)

													tf.debugging.assert_near(a							,	a							,	rtol=1E-12    )
													tf.debugging.assert_equal(a							,	a    )







@require_tf
class    _a     (				unittest.TestCase					,							lowercase__							):






							"""simple docstring"""

							if is_tf_available():
														snake_case_							 =						{
														    "AutoModelForCausalLM": TFAutoModelForCausalLM,
														    "AutoModelForSpeechSeq2Seq": TFAutoModelForSpeechSeqaSeq,
														    "AutoModelForSeq2SeqLM": TFAutoModelForSeqaSeqLM,
														    "AutoModelForVision2Seq": TFAutoModelForVisionaSeq,
														    "LogitsProcessorList": TFLogitsProcessorList,
														    "MinLengthLogitsProcessor": TFMinLengthLogitsProcessor,
														    "create_tensor_fn": tf.convert_to_tensor,
														    "floats_tensor": floats_tensor,
														    "return_tensors": "tf",
														}

							@slow
							def      A_  (      self				:     Optional[Any]    )	->List[Any]:
													# TF-only test: tf.saved_model export
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"    )
													SCREAMING_SNAKE_CASE__     :				List[str]   =					2
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					2



													class    _a     (				tf.Module							):






																				"""simple docstring"""

																				def __init__(      self				:     List[str]							,	a				:     Any    )	->List[str]:
																										super(a							,	self    ).__init__()
																										SCREAMING_SNAKE_CASE__     :				List[Any]   =					model






																				@tf.function(
																				    input_signature=(
																				        tf.TensorSpec((None, input_length)							,	tf.intaa							,	name="input_ids"    ),
																				        tf.TensorSpec((None, input_length)							,	tf.intaa							,	name="attention_mask"    ),
																				    )							,	jit_compile=a							,	)
																				def      A_  (      self				:     Tuple							,	a				:     Optional[Any]							,	a				:     str    )	->List[Any]:
																										SCREAMING_SNAKE_CASE__     :				Tuple   =					self.model.generate(
																										    input_ids=a							,	attention_mask=a							,	max_new_tokens=a							,	return_dict_in_generate=a							,	)
																										return {"sequences": outputs["sequences"]}







													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					[[2, 0], [1_02, 1_03]]
													SCREAMING_SNAKE_CASE__     :				List[str]   =					[[1, 0], [1, 1]]
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					DummyModel(model=a    )
													with tempfile.TemporaryDirectory() as tmp_dir:
																			tf.saved_model.save(a							,	a							,	signatures={"serving_default": dummy_model.serving}    )
																			SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					tf.saved_model.load(a    ).signatures["serving_default"]
																			for batch_size in range(1							,	len(a    ) + 1    ):
																									SCREAMING_SNAKE_CASE__     :				int   =					{
																									    "input_ids": tf.constant(dummy_input_ids[:batch_size]    ),
																									    "attention_mask": tf.constant(dummy_attention_masks[:batch_size]    ),
																									}
																									SCREAMING_SNAKE_CASE__     :				List[Any]   =					serving_func(**a    )["sequences"]
																									SCREAMING_SNAKE_CASE__     :				List[str]   =					test_model.generate(**a							,	max_new_tokens=a    )
																									tf.debugging.assert_equal(a							,	a    )

							@slow
							def      A_  (      self				:     List[str]    )	->Any:
													# TF-only test: tf.saved_model export
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"    )
													SCREAMING_SNAKE_CASE__     :				Dict   =					1
													SCREAMING_SNAKE_CASE__     :				Any   =					2



													class    _a     (				tf.Module							):






																				"""simple docstring"""

																				def __init__(      self				:     List[str]							,	a				:     Union[str, Any]    )	->str:
																										super(a							,	self    ).__init__()
																										SCREAMING_SNAKE_CASE__     :				List[str]   =					model






																				@tf.function(
																				    input_signature=(
																				        tf.TensorSpec((batch_size, None)							,	tf.intaa							,	name="input_ids"    ),
																				        tf.TensorSpec((batch_size, None)							,	tf.intaa							,	name="attention_mask"    ),
																				    )							,	jit_compile=a							,	)
																				def      A_  (      self				:     str							,	a				:     Tuple							,	a				:     List[Any]    )	->List[Any]:
																										SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.model.generate(
																										    input_ids=a							,	attention_mask=a							,	max_new_tokens=a							,	return_dict_in_generate=a							,	)
																										return {"sequences": outputs["sequences"]}







													SCREAMING_SNAKE_CASE__     :				Tuple   =					[[2], [1_02, 1_03]]
													SCREAMING_SNAKE_CASE__     :				str   =					[[1], [1, 1]]
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					DummyModel(model=a    )
													with tempfile.TemporaryDirectory() as tmp_dir:
																			tf.saved_model.save(a							,	a							,	signatures={"serving_default": dummy_model.serving}    )
																			SCREAMING_SNAKE_CASE__     :				Optional[int]   =					tf.saved_model.load(a    ).signatures["serving_default"]
																			for input_row in range(len(a    )    ):
																									SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					{
																									    "input_ids": tf.constant([dummy_input_ids[input_row]]    ),
																									    "attention_mask": tf.constant([dummy_attention_masks[input_row]]    ),
																									}
																									SCREAMING_SNAKE_CASE__     :				List[Any]   =					serving_func(**a    )["sequences"]
																									SCREAMING_SNAKE_CASE__     :				Optional[int]   =					test_model.generate(**a							,	max_new_tokens=a    )
																									tf.debugging.assert_equal(a							,	a    )

							@slow
							@require_tensorflow_text
							def      A_  (      self				:     Tuple    )	->List[str]:
													# TF-only test: tf.saved_model export
													with tempfile.TemporaryDirectory() as tmp_dir:
																			# file needed to load the TF tokenizer
																			hf_hub_download(repo_id="google/flan-t5-small"							,	filename="spiece.model"							,	local_dir=a    )



																			class    _a     (				tf.keras.layers.Layer							):






																										"""simple docstring"""

																										def __init__(      self				:     int    )	->str:
																																super().__init__()
																																SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					text.SentencepieceTokenizer(
																																    model=tf.io.gfile.GFile(os.path.join(a							,	"spiece.model"    )							,	"rb"    ).read()    )
																																SCREAMING_SNAKE_CASE__     :				str   =					TFAutoModelForSeqaSeqLM.from_pretrained("hf-internal-testing/tiny-random-t5"    )






																										def      A_  (      self				:     Any							,	a				:     Union[str, Any]							,	*a				:     Optional[int]							,	**a				:     Any    )	->Optional[Any]:
																																SCREAMING_SNAKE_CASE__     :				Any   =					self.tokenizer.tokenize(a    )
																																SCREAMING_SNAKE_CASE__     :				int   =					text.pad_model_inputs(
																																    a							,	max_seq_length=64							,	pad_value=self.model.config.pad_token_id    )
																																SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.model.generate(input_ids=a							,	attention_mask=a    )
																																return self.tokenizer.detokenize(a    )







																			SCREAMING_SNAKE_CASE__     :				Tuple   =					CompleteSentenceTransformer()
																			SCREAMING_SNAKE_CASE__     :				Optional[int]   =					tf.keras.layers.Input(shape=(1,)							,	dtype=tf.string							,	name="inputs"    )
																			SCREAMING_SNAKE_CASE__     :				List[Any]   =					complete_model(a    )
																			SCREAMING_SNAKE_CASE__     :				List[str]   =					tf.keras.Model(a							,	a    )
																			keras_model.save(a    )

							def      A_  (      self				:     Dict    )	->Optional[int]:
													# Has PT equivalent: this test relies on random sampling
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					{
													    "do_sample": True,
													    "num_beams": 1,
													    "top_p": 0.7,
													    "top_k": 10,
													    "temperature": 0.7,
													}
													SCREAMING_SNAKE_CASE__     :				Dict   =					14

													SCREAMING_SNAKE_CASE__     :				str   =					AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2"    )
													SCREAMING_SNAKE_CASE__     :				int   =					"Hello, my dog is cute and"
													SCREAMING_SNAKE_CASE__     :				int   =					tokenizer(a							,	return_tensors="tf"    )
													SCREAMING_SNAKE_CASE__     :				Any   =					TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"    )

													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					6_38
													# forces the generation to happen on CPU, to avoid GPU-related quirks
													with tf.device(":/CPU:0"    ):
																			tf.random.set_seed(0    )
																			SCREAMING_SNAKE_CASE__     :				Any   =					model.generate(**a							,	eos_token_id=a							,	**a    )
													self.assertTrue(expectation == len(generated_tokens[0]    )    )

													SCREAMING_SNAKE_CASE__     :				str   =					[6_38, 1_98]
													with tf.device(":/CPU:0"    ):
																			tf.random.set_seed(0    )
																			SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					model.generate(**a							,	eos_token_id=a							,	**a    )
													self.assertTrue(expectation == len(generated_tokens[0]    )    )






							def      A_  (      self				:     Optional[int]    )	->Dict:
													# Has PT equivalent: ample use of framework-specific code
													SCREAMING_SNAKE_CASE__     :				str   =					AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-bart"    )
													SCREAMING_SNAKE_CASE__     :				str   =					"Hugging Face is a technology company based in New York and Paris."
													SCREAMING_SNAKE_CASE__     :				str   =					bart_tokenizer(a							,	return_tensors="tf"    ).input_ids
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					TFBartForConditionalGeneration.from_pretrained("hf-internal-testing/tiny-random-bart"    )
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					bart_model.generate(a    ).numpy()



													class    _a     (				lowercase__							):






																				"""simple docstring"""

																				def      A_  (      self				:     Optional[Any]							,	a				:     List[str]							,	a				:     Dict=None							,	**a				:     str    )	->Optional[int]:
																										return super().call(a							,	**a    )







													SCREAMING_SNAKE_CASE__     :				Dict   =					FakeBart.from_pretrained("hf-internal-testing/tiny-random-bart"    )
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					bart_model.generate(a							,	foo="bar"    ).numpy()
													self.assertTrue(np.array_equal(a							,	a    )    )



													class    _a     (				bart_model.model.encoder.__class__							):






																				"""simple docstring"""

																				def      A_  (      self				:     Any							,	a				:     Tuple							,	**a				:     Union[str, Any]    )	->Any:
																										return super().call(a							,	**a    )







													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					FakeEncoder(bart_model.config							,	bart_model.model.shared    )
													SCREAMING_SNAKE_CASE__     :				Tuple   =					fake_encoder

													# Normal generation still works (the output will be different because the encoder weights are different)
													SCREAMING_SNAKE_CASE__     :				Tuple   =					bart_model.generate(a    ).numpy()
													with self.assertRaises(a    ):
																			# FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
																			bart_model.generate(a							,	foo="bar"    )






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


__lowercase       :int       =  logging.get_logger(__name__)



class    _a     (				lowercase__							):






							"""simple docstring"""

							snake_case_							 =						["pixel_values"]

							def __init__(      self				:     int							,	a				:     bool = True							,	a				:     Optional[Dict[str, int]] = None							,	a				:     PILImageResampling = PILImageResampling.BILINEAR							,	a				:     bool = True							,	a				:     Dict[str, int] = None							,	a				:     bool = True							,	a				:     Union[int, float] = 1 / 2_55							,	a				:     bool = True							,	a				:     Optional[Union[float, List[float]]] = None							,	a				:     Optional[Union[float, List[float]]] = None							,	**a				:     List[str]							,	)	->None:
													super().__init__(**a    )
													SCREAMING_SNAKE_CASE__     :				List[str]   =					size if size is not None else {"shortest_edge": 2_56}
													SCREAMING_SNAKE_CASE__     :				Any   =					get_size_dict(a							,	default_to_square=a    )
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					crop_size if crop_size is not None else {"height": 2_24, "width": 2_24}
													SCREAMING_SNAKE_CASE__     :				Dict   =					get_size_dict(a    )
													SCREAMING_SNAKE_CASE__     :				List[str]   =					do_resize
													SCREAMING_SNAKE_CASE__     :				List[str]   =					size
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					resample
													SCREAMING_SNAKE_CASE__     :				int   =					do_center_crop
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					crop_size
													SCREAMING_SNAKE_CASE__     :				Any   =					do_rescale
													SCREAMING_SNAKE_CASE__     :				Any   =					rescale_factor
													SCREAMING_SNAKE_CASE__     :				int   =					do_normalize
													SCREAMING_SNAKE_CASE__     :				str   =					image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
													SCREAMING_SNAKE_CASE__     :				int   =					image_std if image_std is not None else IMAGENET_STANDARD_STD

							def      A_  (      self				:     Tuple							,	a				:     np.ndarray							,	a				:     Dict[str, int]							,	a				:     PILImageResampling = PILImageResampling.BICUBIC							,	a				:     Optional[Union[str, ChannelDimension]] = None							,	**a				:     Optional[int]							,	)	->np.ndarray:
													SCREAMING_SNAKE_CASE__     :				List[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()}"""    )
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					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      A_  (      self				:     List[Any]							,	a				:     np.ndarray							,	a				:     Dict[str, int]							,	a				:     Optional[Union[str, ChannelDimension]] = None							,	**a				:     List[Any]							,	)	->np.ndarray:
													SCREAMING_SNAKE_CASE__     :				Tuple   =					get_size_dict(a    )
													return center_crop(a							,	size=(size["height"], size["width"])							,	data_format=a							,	**a    )

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

							def      A_  (      self				:     Union[str, 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      A_  (      self				:     Tuple							,	a				:     ImageInput							,	a				:     Optional[bool] = None							,	a				:     Dict[str, int] = None							,	a				:     PILImageResampling = None							,	a				:     bool = None							,	a				:     Dict[str, int] = None							,	a				:     Optional[bool] = None							,	a				:     Optional[float] = None							,	a				:     Optional[bool] = None							,	a				:     Optional[Union[float, List[float]]] = None							,	a				:     Optional[Union[float, List[float]]] = None							,	a				:     Optional[Union[str, TensorType]] = None							,	a				:     Union[str, ChannelDimension] = ChannelDimension.FIRST							,	**a				:     Any							,	)	->Optional[int]:
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					do_resize if do_resize is not None else self.do_resize
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					size if size is not None else self.size
													SCREAMING_SNAKE_CASE__     :				Dict   =					get_size_dict(a							,	default_to_square=a    )
													SCREAMING_SNAKE_CASE__     :				str   =					resample if resample is not None else self.resample
													SCREAMING_SNAKE_CASE__     :				List[str]   =					do_center_crop if do_center_crop is not None else self.do_center_crop
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					crop_size if crop_size is not None else self.crop_size
													SCREAMING_SNAKE_CASE__     :				Dict   =					get_size_dict(a    )
													SCREAMING_SNAKE_CASE__     :				List[str]   =					do_rescale if do_rescale is not None else self.do_rescale
													SCREAMING_SNAKE_CASE__     :				int   =					rescale_factor if rescale_factor is not None else self.rescale_factor
													SCREAMING_SNAKE_CASE__     :				Dict   =					do_normalize if do_normalize is not None else self.do_normalize
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					image_mean if image_mean is not None else self.image_mean
													SCREAMING_SNAKE_CASE__     :				Tuple   =					image_std if image_std is not None else self.image_std

													SCREAMING_SNAKE_CASE__     :				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."    )

													# All transformations expect numpy arrays.
													SCREAMING_SNAKE_CASE__     :				List[str]   =					[to_numpy_array(a    ) for image in images]

													if do_resize:
																			SCREAMING_SNAKE_CASE__     :				Tuple   =					[self.resize(image=a							,	size=a							,	resample=a    ) for image in images]

													if do_center_crop:
																			SCREAMING_SNAKE_CASE__     :				List[Any]   =					[self.center_crop(image=a							,	size=a    ) for image in images]

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

													if do_normalize:
																			SCREAMING_SNAKE_CASE__     :				Dict   =					[self.normalize(image=a							,	mean=a							,	std=a    ) for image in images]

													SCREAMING_SNAKE_CASE__     :				Dict   =					[to_channel_dimension_format(a							,	a    ) for image in images]

													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					{"pixel_values": images}
													return BatchFeature(data=a							,	tensor_type=a    )