code: 
  # Copyright (c) 2021-, NVIDIA CORPORATION.  All rights reserved.
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  #     http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  
  ####################################################################################################
  
  #
  # Note: If when running this conversion script you're getting an exception:
  #     ModuleNotFoundError: No module named 'megatron.model.enums'
  # you need to tell python where to find the clone of Megatron-LM, e.g.:
  #
  # cd /tmp
  # git clone https://github.com/NVIDIA/Megatron-LM
  # PYTHONPATH=/tmp/Megatron-LM python src/transformers/models/megatron_bert/convert_megatron_bert_checkpoint.py ...
  #
  # if you already have it cloned elsewhere, simply adjust the path to the existing path
  #
  # If the training was done using a Megatron-LM fork, e.g.,
  # https://github.com/microsoft/Megatron-DeepSpeed/ then chances are that you need to have that one
  # in your path, i.e., /path/to/Megatron-DeepSpeed/
  #
  
  import argparse
  import os
  import re
  import zipfile
  
  import torch
  
  from transformers import MegatronBertConfig
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__=0	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				if name is None:
  								lowercase						    =			None
  				else:
  								lowercase						    =			"." * max(0		,						spaces - 2	) + "# {:" + str(50 - spaces	) + "s}"
  								lowercase						    =			fmt.format(__magic_name__	)
  
  				# Print and recurse (if needed).
  				if isinstance(__magic_name__		,						__magic_name__	):
  								if msg is not None:
  												print(__magic_name__	)
  								for k in val.keys():
  												recursive_print(__magic_name__		,						val[k]		,						spaces + 2	)
  				elif isinstance(__magic_name__		,						torch.Tensor	):
  								print(__magic_name__		,						":"		,						val.size()	)
  				else:
  								print(__magic_name__		,						":"		,						__magic_name__	)
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			param.size()
  				if checkpoint_version == 1.0:
  								# version 1.0 stores [num_heads * hidden_size * num_splits, :]
  								lowercase						    =			(num_heads, hidden_size, num_splits) + input_shape[1:]
  								lowercase						    =			param.view(*__magic_name__	)
  								lowercase						    =			param.transpose(0		,						2	)
  								lowercase						    =			param.transpose(1		,						2	).contiguous()
  				elif checkpoint_version >= 2.0:
  								# other versions store [num_heads * num_splits * hidden_size, :]
  								lowercase						    =			(num_heads, num_splits, hidden_size) + input_shape[1:]
  								lowercase						    =			param.view(*__magic_name__	)
  								lowercase						    =			param.transpose(0		,						1	).contiguous()
  				lowercase						    =			param.view(*__magic_name__	)
  				return param
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			{}
  
  				# old versions did not store training args
  				lowercase						    =			input_state_dict.get("args"		,						__magic_name__	)
  				if ds_args is not None:
  								# do not make the user write a config file when the exact dimensions/sizes are already in the checkpoint
  								# from pprint import pprint
  								# pprint(vars(ds_args))
  
  								lowercase						    =			ds_args.tokenizer_type
  								lowercase						    =			ds_args.padded_vocab_size
  								lowercase						    =			ds_args.max_position_embeddings
  								lowercase						    =			ds_args.hidden_size
  								lowercase						    =			ds_args.num_layers
  								lowercase						    =			ds_args.num_attention_heads
  								lowercase						    =			ds_args.ffn_hidden_size if "ffn_hidden_size" in ds_args else 4 * ds_args.hidden_size
  								# pprint(config)
  
  				# The number of heads.
  				lowercase						    =			config.num_attention_heads
  				# The hidden_size per head.
  				lowercase						    =			config.hidden_size // heads
  				# Megatron-LM checkpoint version
  				if "checkpoint_version" in input_state_dict.keys():
  								lowercase						    =			input_state_dict["checkpoint_version"]
  				else:
  								lowercase						    =			0.0
  
  				# The model.
  				lowercase						    =			input_state_dict["model"]
  				# The language model.
  				lowercase						    =			model["language_model"]
  				# The embeddings.
  				lowercase						    =			lm["embedding"]
  
  				# The word embeddings.
  				lowercase						    =			embeddings["word_embeddings"]["weight"]
  				# Truncate the embedding table to vocab_size rows.
  				lowercase						    =			word_embeddings[: config.vocab_size, :]
  				# Store the word embeddings.
  				lowercase						    =			word_embeddings
  
  				# The position embeddings.
  				lowercase						    =			embeddings["position_embeddings"]["weight"]
  				assert pos_embeddings.size(0	) == config.max_position_embeddings and pos_embeddings.size(1	) == config.hidden_size
  				# Store the position embeddings.
  				lowercase						    =			pos_embeddings
  
  				# The token-type embeddings.
  				lowercase						    =			embeddings["tokentype_embeddings"]["weight"]
  				# Store the position embeddings.
  				lowercase						    =			tokentype_embeddings
  
  				# The transformer.
  				lowercase						    =			lm["transformer"] if "transformer" in lm.keys() else lm["encoder"]
  
  				# The regex to extract layer names.
  				lowercase						    =			re.compile(r"layers\.(\d+)\.([a-z0-9_.]+)\.([a-z]+)"	)
  
  				# The simple map of names for "automated" rules.
  				lowercase						    =			{
  				    "attention.dense": ".attention.output.dense.",
  				    "self_attention.dense": ".attention.output.dense.",
  				    "mlp.dense_h_to_4h": ".intermediate.dense.",
  				    "mlp.dense_4h_to_h": ".output.dense.",
  				}
  
  				# Keep track of the attention/query/value tensor.
  				lowercase						    =			None
  
  				# Extract the layers.
  				for key, val in transformer.items():
  								# Match the name.
  								lowercase						    =			layer_re.match(__magic_name__	)
  
  								# Stop if that's not a layer
  								if m is None:
  												break
  
  								# The index of the layer.
  								lowercase						    =			int(m.group(1	)	)
  								# The name of the operation.
  								lowercase						    =			m.group(2	)
  								# Is it a weight or a bias?
  								lowercase						    =			m.group(3	)
  
  								# The name of the layer.
  								lowercase						    =			F'''bert.encoder.layer.{layer_idx}'''
  
  								# For layernorm(s), simply store the layer norm.
  								if op_name.endswith("layernorm"	):
  												lowercase						    =			"attention.ln" if op_name.startswith("input"	) else "ln"
  												lowercase						    =			val
  
  								# Transpose the QKV matrix.
  								elif (
  								    op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
  								) and weight_or_bias == "weight":
  												# Make sure the QKV pointer is nil.
  												assert attention_qkv_weight is None, ""
  
  												lowercase						    =			fix_query_key_value_ordering(__magic_name__		,						__magic_name__		,						3		,						__magic_name__		,						__magic_name__	)
  												# Store the tensor as we need the bias as well to interleave QKV and biases.
  												lowercase						    =			out_val
  
  								# Transpose the bias.
  								elif (
  								    op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
  								) and weight_or_bias == "bias":
  												# Make sure we read the weight tensor.
  												assert attention_qkv_weight is not None, ""
  
  												# Split the QKV matrix into Q, K and V. Megatron stores Q,K,V interleaved.
  												lowercase						    =			attention_qkv_weight[0 * config.hidden_size : 1 * config.hidden_size, :]
  												lowercase						    =			attention_qkv_weight[1 * config.hidden_size : 2 * config.hidden_size, :]
  												lowercase						    =			attention_qkv_weight[2 * config.hidden_size : 3 * config.hidden_size, :]
  
  												lowercase						    =			fix_query_key_value_ordering(__magic_name__		,						__magic_name__		,						3		,						__magic_name__		,						__magic_name__	)
  												# Split the bias.
  												lowercase						    =			out_val[0 * config.hidden_size : 1 * config.hidden_size]
  												lowercase						    =			out_val[1 * config.hidden_size : 2 * config.hidden_size]
  												lowercase						    =			out_val[2 * config.hidden_size : 3 * config.hidden_size]
  
  												# Store.
  												lowercase						    =			q
  												lowercase						    =			q_bias
  												lowercase						    =			k
  												lowercase						    =			k_bias
  												lowercase						    =			v
  												lowercase						    =			v_bias
  
  												# Clear the stored tensor.
  												lowercase						    =			None
  
  								# Copy weights and biases as is.
  								elif weight_or_bias in ["weight", "bias"]:
  												lowercase						    =			megatron_to_transformers[op_name]
  												lowercase						    =			val
  
      # The final layernorm.
  				lowercase						    =			transformer["final_layernorm.weight"]
  				lowercase						    =			transformer["final_layernorm.bias"]
  
  				# The pooler.
  				lowercase						    =			lm["pooler"]
  
  				# Store the matrix and the bias.
  				lowercase						    =			pooler["dense.weight"]
  				lowercase						    =			pooler["dense.bias"]
  
  				# The LM head from Megatron (for RACE).
  				lowercase						    =			model["lm_head"]
  
  				# The transform matrix.
  				lowercase						    =			lm_head["dense.weight"]
  				lowercase						    =			lm_head["dense.bias"]
  
  				# The transform LN.
  				lowercase						    =			lm_head["layernorm.weight"]
  				lowercase						    =			lm_head["layernorm.bias"]
  
  				# For the decoder, we replicate the weights.
  				lowercase						    =			word_embeddings
  				lowercase						    =			lm_head["bias"]
  
  				# The classifier from Megatron (for MLNI).
  				lowercase						    =			model["binary_head"]
  
  				# Store the classifier.
  				lowercase						    =			binary_head["weight"]
  				lowercase						    =			binary_head["bias"]
  
  				# It should be done!
  				return output_state_dict
  
  def    __snake_case       (  ):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			argparse.ArgumentParser()
  				parser.add_argument("--print-checkpoint-structure"		,						action="store_true"	)
  				parser.add_argument("path_to_checkpoint"		,						type=__magic_name__		,						help="Path to the ZIP file containing the checkpoint"	)
  				parser.add_argument(
  				    "--config_file"		,						default=""		,						type=__magic_name__		,						help="An optional config json file describing the pre-trained model."		,						)
  				lowercase						    =			parser.parse_args()
  
  				# Extract the basename.
  				lowercase						    =			os.path.dirname(args.path_to_checkpoint	)
  
  				# Load the model.
  				# the .zip is very optional, let's keep it for backward compatibility
  				print(F'''Extracting PyTorch state dictionary from "{args.path_to_checkpoint}"'''	)
  				if args.path_to_checkpoint.endswith(".zip"	):
  								with zipfile.ZipFile(args.path_to_checkpoint		,						"r"	) as checkpoint:
  												with checkpoint.open("release/mp_rank_00/model_optim_rng.pt"	) as pytorch_dict:
  																lowercase						    =			torch.load(__magic_name__		,						map_location="cpu"	)
  				else:
  								lowercase						    =			torch.load(args.path_to_checkpoint		,						map_location="cpu"	)
  
  				if args.config_file == "":
  								# Default config of megatron-bert 345m
  								lowercase						    =			MegatronBertConfig()
  
  								# different megatron-bert-*-345m models have different vocab sizes, so override the default
  								# config (which is for megatron-bert-cased-345m) with the actual vocab dimension
  								lowercase						    =			input_state_dict["model"]["lm_head"]["bias"].numel()
  				else:
  								lowercase						    =			MegatronBertConfig.from_json_file(args.config_file	)
  
  				# Convert.
  				print("Converting"	)
  				lowercase						    =			convert_megatron_checkpoint(__magic_name__		,						__magic_name__		,						__magic_name__	)
  
  				# Print the structure of converted state dict.
  				if args.print_checkpoint_structure:
  								recursive_print(__magic_name__		,						__magic_name__	)
  
  				# Store the config to file.
  				print("Saving config"	)
  				config.save_pretrained(__magic_name__	)
  
  				# Store the state_dict to file.
  				lowercase						    =			os.path.join(__magic_name__		,						"pytorch_model.bin"	)
  				print(F'''Saving checkpoint to "{output_checkpoint_file}"'''	)
  				torch.save(__magic_name__		,						__magic_name__	)
  
  
  ####################################################################################################
  
  if __name__ == "__main__":
  						main()
  
  ####################################################################################################
  
style_context: 
  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
  
  
  _snake_case			:       Tuple      =						logging.get_logger(__name__)
  
  
  if is_vision_available():
  						import PIL
  
  
  
  
  
  class      UpperCamelCase_			(			__a		):
  
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						UpperCamelCase			:     Optional[int]							      =				['''pixel_values''']
  
  
  
  
  
  						def __init__( self       :List[str]		,						lowerCAmelCase__       :bool = True		,						lowerCAmelCase__       :Dict[str, int] = None		,						lowerCAmelCase__       :PILImageResampling = PILImageResampling.BILINEAR		,						lowerCAmelCase__       :bool = True		,						lowerCAmelCase__       :bool = False		,						lowerCAmelCase__       :bool = True		,						lowerCAmelCase__       :bool = True		,						lowerCAmelCase__       :Union[int, float] = 1 / 255		,						lowerCAmelCase__       :bool = True		,						lowerCAmelCase__       :Optional[Union[float, List[float]]] = None		,						lowerCAmelCase__       :Optional[Union[float, List[float]]] = None		,						**lowerCAmelCase__       :int		,						)     ->None:
  										super().__init__(**lowerCAmelCase__    )
  
  										lowercase						    =			size if size is not None else {"height": 2560, "width": 1920}
  										if isinstance(lowerCAmelCase__		,						(tuple, list)    ):
  														# The previous feature extractor size parameter was in (width, height) format
  														lowercase						    =			size[::-1]
  										lowercase						    =			get_size_dict(lowerCAmelCase__    )
  
  										lowercase						    =			do_resize
  										lowercase						    =			size
  										lowercase						    =			resample
  										lowercase						    =			do_thumbnail
  										lowercase						    =			do_align_long_axis
  										lowercase						    =			do_pad
  										lowercase						    =			do_rescale
  										lowercase						    =			rescale_factor
  										lowercase						    =			do_normalize
  										lowercase						    =			image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
  										lowercase						    =			image_std if image_std is not None else IMAGENET_STANDARD_STD
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Optional[Any]		,						lowerCAmelCase__       :np.ndarray		,						lowerCAmelCase__       :Dict[str, int]		,						lowerCAmelCase__       :Optional[Union[str, ChannelDimension]] = None    )     ->np.ndarray:
  										lowercase    ,  lowercase						    =			get_image_size(lowerCAmelCase__    )
  										lowercase    ,  lowercase						    =			size["height"], size["width"]
  
  										if (output_width < output_height and input_width > input_height) or (
  										    output_width > output_height and input_width < input_height
  										):
  														lowercase						    =			np.rotaa(lowerCAmelCase__		,						3    )
  
  										if data_format is not None:
  														lowercase						    =			to_channel_dimension_format(lowerCAmelCase__		,						lowerCAmelCase__    )
  
  										return image
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Tuple		,						lowerCAmelCase__       :np.ndarray		,						lowerCAmelCase__       :Dict[str, int]		,						lowerCAmelCase__       :bool = False		,						lowerCAmelCase__       :Optional[Union[str, ChannelDimension]] = None		,						)     ->np.ndarray:
  										lowercase    ,  lowercase						    =			size["height"], size["width"]
  										lowercase    ,  lowercase						    =			get_image_size(lowerCAmelCase__    )
  
  										lowercase						    =			output_width - input_width
  										lowercase						    =			output_height - input_height
  
  										if random_padding:
  														lowercase						    =			np.random.randint(low=0		,						high=delta_height + 1    )
  														lowercase						    =			np.random.randint(low=0		,						high=delta_width + 1    )
  										else:
  														lowercase						    =			delta_height // 2
  														lowercase						    =			delta_width // 2
  
  										lowercase						    =			delta_height - pad_top
  										lowercase						    =			delta_width - pad_left
  
  										lowercase						    =			((pad_top, pad_bottom), (pad_left, pad_right))
  										return pad(lowerCAmelCase__		,						lowerCAmelCase__		,						data_format=lowerCAmelCase__    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Dict		,						*lowerCAmelCase__       :Union[str, Any]		,						**lowerCAmelCase__       :str    )     ->List[str]:
  										logger.info("pad is deprecated and will be removed in version 4.27. Please use pad_image instead."    )
  										return self.pad_image(*lowerCAmelCase__		,						**lowerCAmelCase__    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Tuple		,						lowerCAmelCase__       :np.ndarray		,						lowerCAmelCase__       :Dict[str, int]		,						lowerCAmelCase__       :PILImageResampling = PILImageResampling.BICUBIC		,						lowerCAmelCase__       :Optional[Union[str, ChannelDimension]] = None		,						**lowerCAmelCase__       :Dict		,						)     ->np.ndarray:
  										lowercase    ,  lowercase						    =			get_image_size(lowerCAmelCase__    )
  										lowercase    ,  lowercase						    =			size["height"], size["width"]
  
  										# We always resize to the smallest of either the input or output size.
  										lowercase						    =			min(lowerCAmelCase__		,						lowerCAmelCase__    )
  										lowercase						    =			min(lowerCAmelCase__		,						lowerCAmelCase__    )
  
  										if height == input_height and width == input_width:
  														return image
  
  										if input_height > input_width:
  														lowercase						    =			int(input_width * height / input_height    )
  										elif input_width > input_height:
  														lowercase						    =			int(input_height * width / input_width    )
  
  										return resize(
  										    lowerCAmelCase__		,						size=(height, width)		,						resample=lowerCAmelCase__		,						reducing_gap=2.0		,						data_format=lowerCAmelCase__		,						**lowerCAmelCase__    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :List[str]		,						lowerCAmelCase__       :np.ndarray		,						lowerCAmelCase__       :Dict[str, int]		,						lowerCAmelCase__       :PILImageResampling = PILImageResampling.BICUBIC		,						lowerCAmelCase__       :Optional[Union[str, ChannelDimension]] = None		,						**lowerCAmelCase__       :List[str]		,						)     ->np.ndarray:
  										lowercase						    =			get_size_dict(lowerCAmelCase__    )
  										lowercase						    =			min(size["height"]		,						size["width"]    )
  										lowercase						    =			get_resize_output_image_size(lowerCAmelCase__		,						size=lowerCAmelCase__		,						default_to_square=lowerCAmelCase__    )
  										lowercase						    =			resize(lowerCAmelCase__		,						size=lowerCAmelCase__		,						resample=lowerCAmelCase__		,						data_format=lowerCAmelCase__		,						**lowerCAmelCase__    )
  										return resized_image
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Any		,						lowerCAmelCase__       :np.ndarray		,						lowerCAmelCase__       :Union[int, float]		,						lowerCAmelCase__       :Optional[Union[str, ChannelDimension]] = None		,						**lowerCAmelCase__       :List[Any]		,						)     ->List[Any]:
  										return rescale(lowerCAmelCase__		,						scale=lowerCAmelCase__		,						data_format=lowerCAmelCase__		,						**lowerCAmelCase__    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :List[str]		,						lowerCAmelCase__       :np.ndarray		,						lowerCAmelCase__       :Union[float, List[float]]		,						lowerCAmelCase__       :Union[float, List[float]]		,						lowerCAmelCase__       :Optional[Union[str, ChannelDimension]] = None		,						**lowerCAmelCase__       :str		,						)     ->np.ndarray:
  										return normalize(lowerCAmelCase__		,						mean=lowerCAmelCase__		,						std=lowerCAmelCase__		,						data_format=lowerCAmelCase__		,						**lowerCAmelCase__    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Optional[Any]		,						lowerCAmelCase__       :ImageInput		,						lowerCAmelCase__       :bool = None		,						lowerCAmelCase__       :Dict[str, int] = None		,						lowerCAmelCase__       :PILImageResampling = None		,						lowerCAmelCase__       :bool = None		,						lowerCAmelCase__       :bool = None		,						lowerCAmelCase__       :bool = None		,						lowerCAmelCase__       :bool = False		,						lowerCAmelCase__       :bool = None		,						lowerCAmelCase__       :float = None		,						lowerCAmelCase__       :bool = None		,						lowerCAmelCase__       :Optional[Union[float, List[float]]] = None		,						lowerCAmelCase__       :Optional[Union[float, List[float]]] = None		,						lowerCAmelCase__       :Optional[Union[str, TensorType]] = None		,						lowerCAmelCase__       :Optional[ChannelDimension] = ChannelDimension.FIRST		,						**lowerCAmelCase__       :Tuple		,						)     ->PIL.Image.Image:
  										lowercase						    =			do_resize if do_resize is not None else self.do_resize
  										lowercase						    =			size if size is not None else self.size
  										if isinstance(lowerCAmelCase__		,						(tuple, list)    ):
  														# Previous feature extractor had size in (width, height) format
  														lowercase						    =			size[::-1]
  										lowercase						    =			get_size_dict(lowerCAmelCase__    )
  										lowercase						    =			resample if resample is not None else self.resample
  										lowercase						    =			do_thumbnail if do_thumbnail is not None else self.do_thumbnail
  										lowercase						    =			do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
  										lowercase						    =			do_pad if do_pad is not None else self.do_pad
  										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						    =			make_list_of_images(lowerCAmelCase__    )
  
  										if not valid_images(lowerCAmelCase__    ):
  														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.
  										lowercase						    =			[to_numpy_array(lowerCAmelCase__    ) for image in images]
  
  										if do_align_long_axis:
  														lowercase						    =			[self.align_long_axis(lowerCAmelCase__		,						size=lowerCAmelCase__    ) for image in images]
  
  										if do_resize:
  														lowercase						    =			[self.resize(image=lowerCAmelCase__		,						size=lowerCAmelCase__		,						resample=lowerCAmelCase__    ) for image in images]
  
  										if do_thumbnail:
  														lowercase						    =			[self.thumbnail(image=lowerCAmelCase__		,						size=lowerCAmelCase__    ) for image in images]
  
  										if do_pad:
  														lowercase						    =			[self.pad_image(image=lowerCAmelCase__		,						size=lowerCAmelCase__		,						random_padding=lowerCAmelCase__    ) for image in images]
  
  										if do_rescale:
  														lowercase						    =			[self.rescale(image=lowerCAmelCase__		,						scale=lowerCAmelCase__    ) for image in images]
  
  										if do_normalize:
  														lowercase						    =			[self.normalize(image=lowerCAmelCase__		,						mean=lowerCAmelCase__		,						std=lowerCAmelCase__    ) for image in images]
  
  										lowercase						    =			[to_channel_dimension_format(lowerCAmelCase__		,						lowerCAmelCase__    ) for image in images]
  
  										lowercase						    =			{"pixel_values": images}
  										return BatchFeature(data=lowerCAmelCase__		,						tensor_type=lowerCAmelCase__    )
  