





'''simple docstring'''


import argparse
import gc
import os
import threading

import evaluate
import psutil
import torch
from datasets import load_dataset
from torch.distributed.fsdp.fully_sharded_data_parallel import FullOptimStateDictConfig, FullStateDictConfig
from torch.utils.data import DataLoader
from transformers import (
    AutoModelForSequenceClassification,
    AutoTokenizer,
    get_linear_schedule_with_warmup,
    set_seed,
)

from accelerate import Accelerator, DistributedType, FullyShardedDataParallelPlugin


########################################################################
# This is a fully working simple example to use Accelerate
#
# This example trains a Bert base model on GLUE MRPC
# in any of the following settings (with the same script):
#   - single CPU or single GPU
#   - multi GPUS (using PyTorch distributed mode)
#   - (multi) TPUs
#   - fp16 (mixed-precision) or fp32 (normal precision)
#   - FSDP
#
# This example also demonstrates the checkpointing and sharding capabilities
#
# To run it in each of these various modes, follow the instructions
# in the readme for examples:
# https://github.com/huggingface/accelerate/tree/main/examples
#
########################################################################


lowerCAmelCase      :  List[str]      							=16
lowerCAmelCase      :  List[str]      							=32
def 							UpperCAmelCase_						(		__lowerCamelCase      :      Optional[Any]				):
   return int(x / 2**20				)
class    a_     :





     def __enter__(				self	:      Dict		):





        """simple docstring"""




        gc.collect()
        torch.cuda.empty_cache()
        torch.cuda.reset_max_memory_allocated()  # reset the peak gauge to zero
        lowercase_    :int					    =				torch.cuda.memory_allocated()
        lowercase_    :Dict					    =				psutil.Process()

        lowercase_    :Optional[Any]					    =				self.cpu_mem_used()
        lowercase_    :int					    =				True
        lowercase_    :Optional[int]					    =				threading.Thread(target=self.peak_monitor_func		)
        lowercase_    :Union[str, Any]					    =				True
        peak_monitor_thread.start()
        return self





     def 							lowercase__   (				self	:      Dict		):





        """simple docstring"""




        return self.process.memory_info().rss





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





        """simple docstring"""




        lowercase_    :int					    =				-1

        while True:
           lowercase_    :Optional[int]					    =				max(self.cpu_mem_used()			,   self.cpu_peak		)

           # can't sleep or will not catch the peak right (this comment is here on purpose)
           # time.sleep(0.001) # 1msec

           if not self.peak_monitoring:
              break







     def __exit__(				self	:      List[Any]			,   *lowercase	:      Optional[int]		):





        """simple docstring"""




        lowercase_    :List[Any]					    =				False

        gc.collect()
        torch.cuda.empty_cache()
        lowercase_    :Tuple					    =				torch.cuda.memory_allocated()
        lowercase_    :Any					    =				torch.cuda.max_memory_allocated()
        lowercase_    :Optional[Any]					    =				bamb(self.end - self.begin		)
        lowercase_    :Union[str, Any]					    =				bamb(self.peak - self.begin		)

        lowercase_    :Tuple					    =				self.cpu_mem_used()
        lowercase_    :Optional[int]					    =				bamb(self.cpu_end - self.cpu_begin		)
        lowercase_    :Optional[Any]					    =				bamb(self.cpu_peak - self.cpu_begin		)
        # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")


# For testing only
if os.environ.get('''TESTING_MOCKED_DATALOADERS''', None) == "1":
 from accelerate.test_utils.training import mocked_dataloaders

 lowerCAmelCase      :  Optional[int]      							=mocked_dataloaders  # noqa: F811
def 							UpperCAmelCase_						(		__lowerCamelCase      :      Tuple			,__lowerCamelCase      :      str				):
   # For testing only
   if os.environ.get("TESTING_MOCKED_DATALOADERS"			,__lowerCamelCase				) == "1":
      lowercase_    :Optional[Any]					    =				2

   # New Code #
   # Pass the advanced FSDP settings not part of the accelerate config by creating fsdp_plugin
   lowercase_    :List[Any]					    =				FullyShardedDataParallelPlugin(
       state_dict_config=FullStateDictConfig(offload_to_cpu=__lowerCamelCase			,ranka_only=__lowerCamelCase				)			,optim_state_dict_config=FullOptimStateDictConfig(offload_to_cpu=__lowerCamelCase			,ranka_only=__lowerCamelCase				)			,)

   # Initialize accelerator
   if args.with_tracking:
      lowercase_    :str					    =				Accelerator(
          cpu=args.cpu			,mixed_precision=args.mixed_precision			,log_with="wandb"			,project_dir=args.logging_dir			,fsdp_plugin=__lowerCamelCase			,)
   else:
      lowercase_    :List[Any]					    =				Accelerator(fsdp_plugin=__lowerCamelCase				)
   accelerator.print(accelerator.distributed_type				)

   if hasattr(args.checkpointing_steps			,"isdigit"				):
      if args.checkpointing_steps == "epoch":
         lowercase_    :Union[str, Any]					    =				args.checkpointing_steps
      elif args.checkpointing_steps.isdigit():
         lowercase_    :Dict					    =				int(args.checkpointing_steps				)
      else:
         raise ValueError(
             F'Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.'				)
   else:
      lowercase_    :List[str]					    =				None
   # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
   lowercase_    :Union[str, Any]					    =				config["lr"]
   lowercase_    :Dict					    =				int(config["num_epochs"]				)
   lowercase_    :Dict					    =				int(config["seed"]				)
   lowercase_    :Union[str, Any]					    =				int(config["batch_size"]				)

   # We need to initialize the trackers we use, and also store our configuration
   if args.with_tracking:
      lowercase_    :int					    =				vars(__lowerCamelCase				)
      accelerator.init_trackers("fsdp_glue_no_trainer"			,__lowerCamelCase				)

   lowercase_    :int					    =				AutoTokenizer.from_pretrained(args.model_name_or_path				)
   lowercase_    :Dict					    =				load_dataset("glue"			,"mrpc"				)
   lowercase_    :str					    =				evaluate.load("glue"			,"mrpc"				)

   def tokenize_function(__lowerCamelCase      :      Any				):
      # max_length=None => use the model max length (it's actually the default)
      lowercase_    :Optional[Any]					    =				tokenizer(examples["sentence1"]			,examples["sentence2"]			,truncation=__lowerCamelCase			,max_length=__lowerCamelCase				)
      return outputs

   # Apply the method we just defined to all the examples in all the splits of the dataset
   # starting with the main process first:
   with accelerator.main_process_first():
      lowercase_    :int					    =				datasets.map(
          __lowerCamelCase			,batched=__lowerCamelCase			,remove_columns=["idx", "sentence1", "sentence2"]			,)

   # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
   # transformers library
   lowercase_    :Optional[int]					    =				tokenized_datasets.rename_column("label"			,"labels"				)

   # If the batch size is too big we use gradient accumulation
   lowercase_    :int					    =				1
   if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU:
      lowercase_    :List[str]					    =				batch_size // MAX_GPU_BATCH_SIZE
      lowercase_    :Union[str, Any]					    =				MAX_GPU_BATCH_SIZE

   def collate_fn(__lowerCamelCase      :      str				):
      # On TPU it's best to pad everything to the same length or training will be very slow.
      lowercase_    :Optional[Any]					    =				1_28 if accelerator.distributed_type == DistributedType.TPU else None
      # When using mixed precision we want round multiples of 8/16
      if accelerator.mixed_precision == "fp8":
         lowercase_    :List[Any]					    =				16
      elif accelerator.mixed_precision != "no":
         lowercase_    :Dict					    =				8
      else:
         lowercase_    :Union[str, Any]					    =				None

      return tokenizer.pad(
          __lowerCamelCase			,padding="longest"			,max_length=__lowerCamelCase			,pad_to_multiple_of=__lowerCamelCase			,return_tensors="pt"			,)

   # Instantiate dataloaders.
   lowercase_    :Optional[int]					    =				DataLoader(
       tokenized_datasets["train"]			,shuffle=__lowerCamelCase			,collate_fn=__lowerCamelCase			,batch_size=__lowerCamelCase				)
   lowercase_    :List[str]					    =				DataLoader(
       tokenized_datasets["validation"]			,shuffle=__lowerCamelCase			,collate_fn=__lowerCamelCase			,batch_size=__lowerCamelCase				)

   set_seed(__lowerCamelCase				)

   # Instantiate the model (we build the model here so that the seed also control new weights initialization)
   lowercase_    :List[Any]					    =				AutoModelForSequenceClassification.from_pretrained(
       args.model_name_or_path			,return_dict=__lowerCamelCase			,low_cpu_mem_usage=__lowerCamelCase				)

   # New Code #
   # For FSDP feature, it is highly recommended and efficient to prepare the model before creating optimizer
   lowercase_    :Tuple					    =				accelerator.prepare(__lowerCamelCase				)
   accelerator.print(__lowerCamelCase				)

   # Instantiate optimizer
   # New Code #
   # For FSDP feature, at present it doesn't support multiple parameter groups,
   # so we need to create a single parameter group for the whole model
   lowercase_    :List[Any]					    =				torch.optim.AdamW(params=model.parameters()			,lr=__lowerCamelCase			,weight_decay=2e-4				)

   # Instantiate scheduler
   lowercase_    :Dict					    =				get_linear_schedule_with_warmup(
       optimizer=__lowerCamelCase			,num_warmup_steps=10			,num_training_steps=(len(__lowerCamelCase				) * num_epochs) // gradient_accumulation_steps			,)

   # New Code #
   # For FSDP feature, prepare everything except the model as we have already prepared the model
   # before creating the optimizer
   # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
   # prepare method.
   lowercase_    ,							lowercase_    ,							lowercase_    ,							lowercase_    :Tuple					    =				accelerator.prepare(
       __lowerCamelCase			,__lowerCamelCase			,__lowerCamelCase			,__lowerCamelCase				)

   lowercase_    :str					    =				0

   # Potentially load in the weights and states from a previous save
   if args.resume_from_checkpoint:
      if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
         accelerator.print(F'Resumed from checkpoint: {args.resume_from_checkpoint}'				)
         accelerator.load_state(args.resume_from_checkpoint				)
         lowercase_    :Optional[int]					    =				os.path.basename(args.resume_from_checkpoint				)
      else:
         # Get the most recent checkpoint
         lowercase_    :Dict					    =				[f.name for f in os.scandir(os.getcwd()				) if f.is_dir()]
         dirs.sort(key=os.path.getctime				)
         lowercase_    :Optional[Any]					    =				dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
      # Extract `epoch_{i}` or `step_{i}`
      lowercase_    :Optional[Any]					    =				os.path.splitext(__lowerCamelCase				)[0]

      if "epoch" in training_difference:
         num_epochs -= int(training_difference.replace("epoch_"			,""				)				)
         lowercase_    :Any					    =				None
      else:
         lowercase_    :List[str]					    =				int(training_difference.replace("step_"			,""				)				)
         num_epochs -= resume_step // len(__lowerCamelCase				)
         # If resuming by step, we also need to know exactly how far into the DataLoader we went
         lowercase_    :Optional[Any]					    =				(num_epochs * len(__lowerCamelCase				)) - resume_step

    # Now we train the model
   for epoch in range(__lowerCamelCase				):
      # New Code #
      # context manager to track the peak memory usage during the training epoch
      with TorchTracemalloc() as tracemalloc:
         model.train()
         if args.with_tracking:
            lowercase_    :Union[str, Any]					    =				0
         for step, batch in enumerate(__lowerCamelCase				):
            # We need to skip steps until we reach the resumed step
            if args.resume_from_checkpoint and epoch == 0:
               if resume_step is not None and step < resume_step:
                  pass
                # We could avoid this line since we set the accelerator with `device_placement=True`.
            batch.to(accelerator.device				)
            lowercase_    :str					    =				model(**__lowerCamelCase				)
            lowercase_    :Optional[Any]					    =				outputs.loss
            lowercase_    :str					    =				loss / gradient_accumulation_steps
            # We keep track of the loss at each epoch
            if args.with_tracking:
               total_loss += loss.detach().float()
            accelerator.backward(__lowerCamelCase				)
            if step % gradient_accumulation_steps == 0:
               optimizer.step()
               lr_scheduler.step()
               optimizer.zero_grad()
               # accelerator.print(lr_scheduler.get_lr())

            overall_step += 1

            if isinstance(__lowerCamelCase			,__lowerCamelCase				):
               lowercase_    :Optional[int]					    =				F'step_{overall_step}'
               if overall_step % checkpointing_steps == 0:
                  if args.output_dir is not None:
                     lowercase_    :List[str]					    =				os.path.join(args.output_dir			,__lowerCamelCase				)
                  accelerator.save_state(__lowerCamelCase				)
        # New Code #
        # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage
      accelerator.print("Memory before entering the train : {}".format(bamb(tracemalloc.begin				)				)				)
      accelerator.print("Memory consumed at the end of the train (end-begin): {}".format(tracemalloc.used				)				)
      accelerator.print("Peak Memory consumed during the train (max-begin): {}".format(tracemalloc.peaked				)				)
      accelerator.print(
          "Total Peak Memory consumed during the train (max): {}".format(
              tracemalloc.peaked + bamb(tracemalloc.begin				)				)				)
      # Logging the peak memory usage of the GPU to the tracker
      if args.with_tracking:
         accelerator.log(
             {
                 "train_total_peak_memory": tracemalloc.peaked + bamb(tracemalloc.begin				),
             }			,step=__lowerCamelCase			,)

      # New Code #
      # context manager to track the peak memory usage during the evaluation
      with TorchTracemalloc() as tracemalloc:
         model.eval()
         for step, batch in enumerate(__lowerCamelCase				):
            # We could avoid this line since we set the accelerator with `device_placement=True`.
            batch.to(accelerator.device				)
            with torch.no_grad():
               lowercase_    :Union[str, Any]					    =				model(**__lowerCamelCase				)
            lowercase_    :Optional[Any]					    =				outputs.logits.argmax(dim=-1				)
            lowercase_    ,							lowercase_    :Dict					    =				accelerator.gather_for_metrics((predictions, batch["labels"])				)
            metric.add_batch(
                predictions=__lowerCamelCase			,references=__lowerCamelCase			,)

         lowercase_    :str					    =				metric.compute()
         # Use accelerator.print to print only on the main process.
         accelerator.print(F'epoch {epoch}:'			,__lowerCamelCase				)
         if args.with_tracking:
            accelerator.log(
                {
                    "accuracy": eval_metric["accuracy"],
                    "f1": eval_metric["f1"],
                    "train_loss": total_loss.item() / len(__lowerCamelCase				),
                }			,step=__lowerCamelCase			,)

         if checkpointing_steps == "epoch":
            lowercase_    :int					    =				F'epoch_{epoch}'
            if args.output_dir is not None:
               lowercase_    :List[Any]					    =				os.path.join(args.output_dir			,__lowerCamelCase				)
            accelerator.save_state(__lowerCamelCase				)
        # New Code #
        # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage
      accelerator.print("Memory before entering the eval : {}".format(bamb(tracemalloc.begin				)				)				)
      accelerator.print("Memory consumed at the end of the eval (end-begin): {}".format(tracemalloc.used				)				)
      accelerator.print("Peak Memory consumed during the eval (max-begin): {}".format(tracemalloc.peaked				)				)
      accelerator.print(
          "Total Peak Memory consumed during the eval (max): {}".format(tracemalloc.peaked + bamb(tracemalloc.begin				)				)				)
      # Logging the peak memory usage of the GPU to the tracker
      if args.with_tracking:
         accelerator.log(
             {
                 "eval_total_peak_memory": tracemalloc.peaked + bamb(tracemalloc.begin				),
             }			,step=__lowerCamelCase			,)

   if args.with_tracking:
      accelerator.end_training()
def 							UpperCAmelCase_						(		):
   lowercase_    :List[str]					    =				argparse.ArgumentParser(description="Simple example of training script."				)
   parser.add_argument(
       "--mixed_precision"			,type=__lowerCamelCase			,default=__lowerCamelCase			,choices=["no", "fp16", "bf16", "fp8"]			,help="Whether to use mixed precision. Choose"
       "between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10."
       "and an Nvidia Ampere GPU."			,)
   parser.add_argument("--cpu"			,action="store_true"			,help="If passed, will train on the CPU."				)
   parser.add_argument(
       "--checkpointing_steps"			,type=__lowerCamelCase			,default=__lowerCamelCase			,help="Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch."			,)
   parser.add_argument(
       "--resume_from_checkpoint"			,type=__lowerCamelCase			,default=__lowerCamelCase			,help="If the training should continue from a checkpoint folder."			,)
   parser.add_argument(
       "--with_tracking"			,action="store_true"			,help="Whether to load in all available experiment trackers from the environment and use them for logging."			,)
   parser.add_argument(
       "--output_dir"			,type=__lowerCamelCase			,default="."			,help="Optional save directory where all checkpoint folders will be stored. Default is the current working directory."			,)
   parser.add_argument(
       "--logging_dir"			,type=__lowerCamelCase			,default="logs"			,help="Location on where to store experiment tracking logs`"			,)
   parser.add_argument(
       "--model_name_or_path"			,type=__lowerCamelCase			,help="Path to pretrained model or model identifier from huggingface.co/models."			,required=__lowerCamelCase			,)
   lowercase_    :Optional[int]					    =				parser.parse_args()
   lowercase_    :List[str]					    =				{"lr": 2e-5, "num_epochs": 3, "seed": 42, "batch_size": 16}
   training_function(__lowerCamelCase			,__lowerCamelCase				)


if __name__ == "__main__":
 main()









'''simple docstring'''


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


if is_vision_available():
 import PIL


lowerCAmelCase      :  Any      							=logging.get_logger(__name__)
class    a_     (       _lowerCAmelCase							):
     __A  				=    ["pixel_values"]





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





        """simple docstring"""




        super().__init__(**lowercase		)
        lowercase_    :Dict					    =				crop_size if crop_size is not None else {"height": 256, "width": 256}
        lowercase_    :str					    =				get_size_dict(lowercase			,   param_name="crop_size"		)
        lowercase_    :Optional[Any]					    =				size if size is not None else {"height": 224, "width": 224}
        lowercase_    :Union[str, Any]					    =				get_size_dict(lowercase		)

        lowercase_    :Union[str, Any]					    =				do_center_crop
        lowercase_    :str					    =				crop_size
        lowercase_    :List[str]					    =				do_resize
        lowercase_    :str					    =				size
        lowercase_    :Tuple					    =				resample
        lowercase_    :int					    =				do_rescale
        lowercase_    :Union[str, Any]					    =				rescale_factor
        lowercase_    :Tuple					    =				do_normalize
        lowercase_    :List[Any]					    =				image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
        lowercase_    :Optional[int]					    =				image_std if image_std is not None else IMAGENET_DEFAULT_STD





     def 							lowercase__   (				self	:      Any			,   lowercase	:      np.ndarray			,   lowercase	:      Dict[str, int]			,   lowercase	:      Optional[int] = None			,   lowercase	:      Optional[Union[str, ChannelDimension]] = None			,   **lowercase	:      List[Any]			,   ):





        """simple docstring"""




        lowercase_    :Dict					    =				self.size if size is None else size
        lowercase_    :Dict					    =				get_size_dict(lowercase		)
        lowercase_    :List[Any]					    =				get_size_dict(lowercase			,   param_name="crop_size"		)

        lowercase_    ,							lowercase_    :List[str]					    =				get_image_size(lowercase		)
        lowercase_    :List[str]					    =				min(lowercase			,   lowercase		)
        lowercase_    :Tuple					    =				(size["height"] / crop_size["height"]) * min_dim
        lowercase_    :int					    =				(size["width"] / crop_size["width"]) * min_dim
        return center_crop(lowercase			,   size=(cropped_height, cropped_width)			,   data_format=lowercase			,   **lowercase		)





     def 							lowercase__   (				self	:      Union[str, Any]			,   lowercase	:      np.ndarray			,   lowercase	:      Dict[str, int]			,   lowercase	:      PILImageResampling = PIL.Image.BICUBIC			,   lowercase	:      Optional[Union[str, ChannelDimension]] = None			,   **lowercase	:      List[str]			,   ):





        """simple docstring"""




        lowercase_    :Optional[int]					    =				get_size_dict(lowercase		)
        if "height" not in size or "width" not in size:
           raise ValueError(F'The size dictionary must contain the keys \'height\' and \'width\'. Got {size.keys()}'		)
        return resize(
            lowercase			,   size=(size["height"], size["width"])			,   resample=lowercase			,   data_format=lowercase			,   **lowercase		)





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





        """simple docstring"""




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





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





        """simple docstring"""




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







     def 							lowercase__   (				self	:      List[Any]			,   lowercase	:      ImageInput			,   lowercase	:      Optional[bool] = None			,   lowercase	:      Optional[Dict[str, int]] = None			,   lowercase	:      Optional[bool] = None			,   lowercase	:      Optional[Dict[str, int]] = None			,   lowercase	:      PILImageResampling = None			,   lowercase	:      Optional[bool] = None			,   lowercase	:      Optional[float] = None			,   lowercase	:      Optional[bool] = None			,   lowercase	:      Optional[Union[float, List[float]]] = None			,   lowercase	:      Optional[Union[float, List[float]]] = None			,   lowercase	:      Optional[Union[str, TensorType]] = None			,   lowercase	:      ChannelDimension = ChannelDimension.FIRST			,   **lowercase	:      Optional[Any]			,   ):





        """simple docstring"""




        lowercase_    :str					    =				do_center_crop if do_center_crop is not None else self.do_center_crop
        lowercase_    :Union[str, Any]					    =				crop_size if crop_size is not None else self.crop_size
        lowercase_    :Optional[Any]					    =				get_size_dict(lowercase			,   param_name="crop_size"		)
        lowercase_    :Union[str, Any]					    =				do_resize if do_resize is not None else self.do_resize
        lowercase_    :Any					    =				size if size is not None else self.size
        lowercase_    :List[Any]					    =				get_size_dict(lowercase		)
        lowercase_    :Optional[Any]					    =				resample if resample is not None else self.resample
        lowercase_    :Dict					    =				do_rescale if do_rescale is not None else self.do_rescale
        lowercase_    :List[Any]					    =				rescale_factor if rescale_factor is not None else self.rescale_factor
        lowercase_    :str					    =				do_normalize if do_normalize is not None else self.do_normalize
        lowercase_    :Dict					    =				image_mean if image_mean is not None else self.image_mean
        lowercase_    :List[Any]					    =				image_std if image_std is not None else self.image_std

        lowercase_    :Any					    =				make_list_of_images(lowercase		)

        if not valid_images(lowercase		):
           raise ValueError(
               "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
               "torch.Tensor, tf.Tensor or jax.ndarray."		)

        if do_center_crop and crop_size is None:
           raise ValueError("If `do_center_crop` is set to `True`, `crop_size` must be provided."		)

        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_normalize and (image_mean is None or image_std is None):
           raise ValueError("Image mean and image standard deviation must be specified if do_normalize is True."		)

        # All transformations expect numpy arrays.
        lowercase_    :Optional[int]					    =				[to_numpy_array(lowercase		) for image in images]

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

        if do_resize:
           lowercase_    :List[str]					    =				[self.resize(image=lowercase			,   size=lowercase			,   resample=lowercase		) for image in images]

        if do_rescale:
           lowercase_    :List[Any]					    =				[self.rescale(image=lowercase			,   scale=lowercase		) for image in images]

        if do_normalize:
           lowercase_    :Optional[Any]					    =				[self.normalize(image=lowercase			,   mean=lowercase			,   std=lowercase		) for image in images]

        lowercase_    :Optional[Any]					    =				[to_channel_dimension_format(lowercase			,   lowercase		) for image in images]

        lowercase_    :Union[str, Any]					    =				{"pixel_values": images}
        return BatchFeature(data=lowercase			,   tensor_type=lowercase		)


