'''simple docstring'''




import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import SegformerImageProcessor, SwinConfig, UperNetConfig, UperNetForSemanticSegmentation






def __lowerCAmelCase			(							UpperCamelCase__    )     ->   Union[str, Any]:
    __lowerCamelCase          =  3_84
    __lowerCamelCase          =  7
    if "tiny" in model_name:
        __lowerCamelCase          =  96
        __lowerCamelCase          =  (2, 2, 6, 2)
        __lowerCamelCase          =  (3, 6, 12, 24)
    elif "small" in model_name:
        __lowerCamelCase          =  96
        __lowerCamelCase          =  (2, 2, 18, 2)
        __lowerCamelCase          =  (3, 6, 12, 24)
    elif "base" in model_name:
        __lowerCamelCase          =  1_28
        __lowerCamelCase          =  (2, 2, 18, 2)
        __lowerCamelCase          =  (4, 8, 16, 32)
        __lowerCamelCase          =  12
        __lowerCamelCase          =  5_12
    elif "large" in model_name:
        __lowerCamelCase          =  1_92
        __lowerCamelCase          =  (2, 2, 18, 2)
        __lowerCamelCase          =  (6, 12, 24, 48)
        __lowerCamelCase          =  12
        __lowerCamelCase          =  7_68

    # set label information
    __lowerCamelCase          =  1_50
    __lowerCamelCase          =  '''huggingface/label-files'''
    __lowerCamelCase          =  '''ade20k-id2label.json'''
    __lowerCamelCase          =  json.load(open(hf_hub_download(UpperCamelCase__    ,  UpperCamelCase__    ,  repo_type='''dataset'''    )    ,  '''r'''    )    )
    __lowerCamelCase          =  {int(UpperCamelCase__    ): v for k, v in idalabel.items()}
    __lowerCamelCase          =  {v: k for k, v in idalabel.items()}

    __lowerCamelCase          =  SwinConfig(
        embed_dim=UpperCamelCase__    ,  depths=UpperCamelCase__    ,  num_heads=UpperCamelCase__    ,  window_size=UpperCamelCase__    ,  out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4''']    ,  )
    __lowerCamelCase          =  UperNetConfig(
        backbone_config=UpperCamelCase__    ,  auxiliary_in_channels=UpperCamelCase__    ,  num_labels=UpperCamelCase__    ,  idalabel=UpperCamelCase__    ,  labelaid=UpperCamelCase__    ,  )

    return config






def __lowerCAmelCase			(							UpperCamelCase__    )     ->   List[str]:
    __lowerCamelCase          =  []

    # fmt: off
    # stem
    rename_keys.append(('''backbone.patch_embed.projection.weight''', '''backbone.embeddings.patch_embeddings.projection.weight''')    )
    rename_keys.append(('''backbone.patch_embed.projection.bias''', '''backbone.embeddings.patch_embeddings.projection.bias''')    )
    rename_keys.append(('''backbone.patch_embed.norm.weight''', '''backbone.embeddings.norm.weight''')    )
    rename_keys.append(('''backbone.patch_embed.norm.bias''', '''backbone.embeddings.norm.bias''')    )
    # stages
    for i in range(len(config.backbone_config.depths    )    ):
        for j in range(config.backbone_config.depths[i]    ):
            rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.norm1.weight""", f"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""")    )
            rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.norm1.bias""", f"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""")    )
            rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_bias_table""", f"""backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""")    )
            rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_index""", f"""backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""")    )
            rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.weight""", f"""backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""")    )
            rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.bias""", f"""backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""")    )
            rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.norm2.weight""", f"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""")    )
            rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.norm2.bias""", f"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""")    )
            rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.weight""", f"""backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""")    )
            rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.bias""", f"""backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""")    )
            rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.ffn.layers.1.weight""", f"""backbone.encoder.layers.{i}.blocks.{j}.output.dense.weight""")    )
            rename_keys.append((f"""backbone.stages.{i}.blocks.{j}.ffn.layers.1.bias""", f"""backbone.encoder.layers.{i}.blocks.{j}.output.dense.bias""")    )

        if i < 3:
            rename_keys.append((f"""backbone.stages.{i}.downsample.reduction.weight""", f"""backbone.encoder.layers.{i}.downsample.reduction.weight""")    )
            rename_keys.append((f"""backbone.stages.{i}.downsample.norm.weight""", f"""backbone.encoder.layers.{i}.downsample.norm.weight""")    )
            rename_keys.append((f"""backbone.stages.{i}.downsample.norm.bias""", f"""backbone.encoder.layers.{i}.downsample.norm.bias""")    )
        rename_keys.append((f"""backbone.norm{i}.weight""", f"""backbone.hidden_states_norms.stage{i+1}.weight""")    )
        rename_keys.append((f"""backbone.norm{i}.bias""", f"""backbone.hidden_states_norms.stage{i+1}.bias""")    )

    # decode head
    rename_keys.extend(
        [
            ('''decode_head.conv_seg.weight''', '''decode_head.classifier.weight'''),
            ('''decode_head.conv_seg.bias''', '''decode_head.classifier.bias'''),
            ('''auxiliary_head.conv_seg.weight''', '''auxiliary_head.classifier.weight'''),
            ('''auxiliary_head.conv_seg.bias''', '''auxiliary_head.classifier.bias'''),
        ]    )
    # fmt: on

    return rename_keys






def __lowerCAmelCase			(							UpperCamelCase__    ,  UpperCamelCase__    ,  UpperCamelCase__    )     ->   Any:
    __lowerCamelCase          =  dct.pop(UpperCamelCase__    )
    __lowerCamelCase          =  val






def __lowerCAmelCase			(							UpperCamelCase__    ,  UpperCamelCase__    )     ->   Tuple:
    __lowerCamelCase          =  [int(backbone_config.embed_dim * 2**i    ) for i in range(len(backbone_config.depths    )    )]
    for i in range(len(backbone_config.depths    )    ):
        __lowerCamelCase          =  num_features[i]
        for j in range(backbone_config.depths[i]    ):
            # fmt: off
            # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
            __lowerCamelCase          =  state_dict.pop(f"""backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.weight"""    )
            __lowerCamelCase          =  state_dict.pop(f"""backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.bias"""    )
            # next, add query, keys and values (in that order) to the state dict
            __lowerCamelCase          =  in_proj_weight[:dim, :]
            __lowerCamelCase          =  in_proj_bias[: dim]
            __lowerCamelCase          =  in_proj_weight[
                dim : dim * 2, :
            ]
            __lowerCamelCase          =  in_proj_bias[
                dim : dim * 2
            ]
            __lowerCamelCase          =  in_proj_weight[
                -dim :, :
            ]
            __lowerCamelCase          =  in_proj_bias[-dim :]
            # fmt: on






def __lowerCAmelCase			(							UpperCamelCase__    )     ->   Dict:
    __lowerCamelCase     ,  __lowerCamelCase          =  x.shape
    __lowerCamelCase          =  x.reshape(UpperCamelCase__    ,  4    ,  in_channel // 4    )
    __lowerCamelCase          =  x[:, [0, 2, 1, 3], :].transpose(1    ,  2    ).reshape(UpperCamelCase__    ,  UpperCamelCase__    )
    return x






def __lowerCAmelCase			(							UpperCamelCase__    )     ->   Any:
    __lowerCamelCase     ,  __lowerCamelCase          =  x.shape
    __lowerCamelCase          =  x.reshape(UpperCamelCase__    ,  in_channel // 4    ,  4    )
    __lowerCamelCase          =  x[:, :, [0, 2, 1, 3]].transpose(1    ,  2    ).reshape(UpperCamelCase__    ,  UpperCamelCase__    )

    return x






def __lowerCAmelCase			(							UpperCamelCase__    )     ->   Optional[int]:
    __lowerCamelCase          =  x.shape[0]
    __lowerCamelCase          =  x.reshape(4    ,  in_channel // 4    )
    __lowerCamelCase          =  x[[0, 2, 1, 3], :].transpose(0    ,  1    ).reshape(UpperCamelCase__    )
    return x






def __lowerCAmelCase			(							UpperCamelCase__    )     ->   Dict:
    __lowerCamelCase          =  x.shape[0]
    __lowerCamelCase          =  x.reshape(in_channel // 4    ,  4    )
    __lowerCamelCase          =  x[:, [0, 2, 1, 3]].transpose(0    ,  1    ).reshape(UpperCamelCase__    )
    return x






def __lowerCAmelCase			(							UpperCamelCase__    ,  UpperCamelCase__    ,  UpperCamelCase__    )     ->   Any:
    __lowerCamelCase          =  {
        '''upernet-swin-tiny''': '''https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth''',
        '''upernet-swin-small''': '''https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015-ee2fff1c.pth''',
        '''upernet-swin-base''': '''https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459-429057bf.pth''',
        '''upernet-swin-large''': '''https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k_20220318_091743-9ba68901.pth''',
    }
    __lowerCamelCase          =  model_name_to_url[model_name]
    __lowerCamelCase          =  torch.hub.load_state_dict_from_url(UpperCamelCase__    ,  map_location='''cpu'''    ,  file_name=UpperCamelCase__    )[
        '''state_dict'''
    ]

    for name, param in state_dict.items():
        print(UpperCamelCase__    ,  param.shape    )

    __lowerCamelCase          =  get_upernet_config(UpperCamelCase__    )
    __lowerCamelCase          =  UperNetForSemanticSegmentation(UpperCamelCase__    )
    model.eval()

    # replace "bn" => "batch_norm"
    for key in state_dict.copy().keys():
        __lowerCamelCase          =  state_dict.pop(UpperCamelCase__    )
        if "bn" in key:
            __lowerCamelCase          =  key.replace('''bn'''    ,  '''batch_norm'''    )
        __lowerCamelCase          =  val

    # rename keys
    __lowerCamelCase          =  create_rename_keys(UpperCamelCase__    )
    for src, dest in rename_keys:
        rename_key(UpperCamelCase__    ,  UpperCamelCase__    ,  UpperCamelCase__    )
    read_in_q_k_v(UpperCamelCase__    ,  config.backbone_config    )

    # fix downsample parameters
    for key, value in state_dict.items():
        if "downsample" in key:
            if "reduction" in key:
                __lowerCamelCase          =  reverse_correct_unfold_reduction_order(UpperCamelCase__    )
            if "norm" in key:
                __lowerCamelCase          =  reverse_correct_unfold_norm_order(UpperCamelCase__    )

    model.load_state_dict(UpperCamelCase__    )

    # verify on image
    __lowerCamelCase          =  '''https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg'''
    __lowerCamelCase          =  Image.open(requests.get(UpperCamelCase__    ,  stream=UpperCamelCase__    ).raw    ).convert('''RGB'''    )

    __lowerCamelCase          =  SegformerImageProcessor()
    __lowerCamelCase          =  processor(UpperCamelCase__    ,  return_tensors='''pt'''    ).pixel_values

    with torch.no_grad():
        __lowerCamelCase          =  model(UpperCamelCase__    )
        __lowerCamelCase          =  outputs.logits

    print(logits.shape    )
    print('''First values of logits:'''    ,  logits[0, 0, :3, :3]    )
    # assert values
    if model_name == "upernet-swin-tiny":
        __lowerCamelCase          =  torch.tensor(
            [[-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.4_7_9_7, -7.4_7_9_7, -7.3_0_6_8]]    )
    elif model_name == "upernet-swin-small":
        __lowerCamelCase          =  torch.tensor(
            [[-7.1_9_2_1, -7.1_9_2_1, -6.9_5_3_2], [-7.1_9_2_1, -7.1_9_2_1, -6.9_5_3_2], [-7.0_9_0_8, -7.0_9_0_8, -6.8_5_3_4]]    )
    elif model_name == "upernet-swin-base":
        __lowerCamelCase          =  torch.tensor(
            [[-6.5_8_5_1, -6.5_8_5_1, -6.4_3_3_0], [-6.5_8_5_1, -6.5_8_5_1, -6.4_3_3_0], [-6.4_7_6_3, -6.4_7_6_3, -6.3_2_5_4]]    )
    elif model_name == "upernet-swin-large":
        __lowerCamelCase          =  torch.tensor(
            [[-7.5_2_9_7, -7.5_2_9_7, -7.3_8_0_2], [-7.5_2_9_7, -7.5_2_9_7, -7.3_8_0_2], [-7.4_0_4_4, -7.4_0_4_4, -7.2_5_8_6]]    )
    print('''Logits:'''    ,  outputs.logits[0, 0, :3, :3]    )
    assert torch.allclose(outputs.logits[0, 0, :3, :3]    ,  UpperCamelCase__    ,  atol=1E-4    )
    print('''Looks ok!'''    )

    if pytorch_dump_folder_path is not None:
        print(f"""Saving model {model_name} to {pytorch_dump_folder_path}"""    )
        model.save_pretrained(UpperCamelCase__    )
        print(f"""Saving processor to {pytorch_dump_folder_path}"""    )
        processor.save_pretrained(UpperCamelCase__    )

    if push_to_hub:
        print(f"""Pushing model and processor for {model_name} to hub"""    )
        model.push_to_hub(f"""openmmlab/{model_name}"""    )
        processor.push_to_hub(f"""openmmlab/{model_name}"""    )


if __name__ == "__main__":
  __UpperCAmelCase												=argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      "--model_name",
      default="upernet-swin-tiny",
      type=str,
      choices=[f'upernet-swin-{size}' for size in ["tiny", "small", "base", "large"]],
      help="Name of the Swin + UperNet model you'd like to convert.",
  )
  parser.add_argument(
      "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
  )
  parser.add_argument(
      "--push_to_hub", action="store_true", help="Whether or not to push the converted model to the 🤗 hub."
  )

  __UpperCAmelCase												=parser.parse_args()
  convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)

'''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,
    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, is_vision_available, logging


if is_vision_available():
  import PIL


__UpperCAmelCase												=logging.get_logger(__name__)




class    a__				(       UpperCAmelCase__			):
     lowerCamelCase  :					Dict							=["pixel_values"]






     def __init__(			self		:		List[str]  ,    a		:		bool = True  ,    a		:		Dict[str, int] = None  ,    a		:		int = 0.9  ,    a		:		PILImageResampling = PILImageResampling.BICUBIC  ,    a		:		bool = True  ,    a		:		Dict[str, int] = None  ,    a		:		Union[int, float] = 1 / 2_55  ,    a		:		bool = True  ,    a		:		bool = True  ,    a		:		Optional[Union[float, List[float]]] = None  ,    a		:		Optional[Union[float, List[float]]] = None  ,    **a		:		Dict  ,    ):





         """simple docstring"""



         super().__init__(**a   )
         __lowerCamelCase          =  size if size is not None else {'''shortest_edge''': 2_24}
         __lowerCamelCase          =  get_size_dict(a  ,    default_to_square=a   )
         __lowerCamelCase          =  crop_size if crop_size is not None else {'''height''': 2_24, '''width''': 2_24}
         __lowerCamelCase          =  get_size_dict(a  ,    param_name='''crop_size'''   )

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






     def        SCREAMING_SNAKE_CASE__       (			self		:		Any  ,    a		:		np.ndarray  ,    a		:		Dict[str, int]  ,    a		:		Optional[float] = None  ,    a		:		PILImageResampling = PILImageResampling.BICUBIC  ,    a		:		Optional[Union[str, ChannelDimension]] = None  ,    **a		:		List[str]  ,    ):





         """simple docstring"""



         __lowerCamelCase          =  get_size_dict(a  ,    default_to_square=a   )
         if "shortest_edge" not in size and ("height" not in size or "width" not in size):
             raise ValueError(f"""size must contain 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}"""   )
         if crop_pct is not None:
             if "shortest_edge" in size:
                 __lowerCamelCase          =  int(size['''shortest_edge'''] / crop_pct   )
             elif "height" in size and "width" in size:
                 if size["height"] == size["width"]:
                     __lowerCamelCase          =  int(size['''height'''] / crop_pct   )
                 else:
                     __lowerCamelCase          =  (int(size['''height'''] / crop_pct   ), int(size['''width'''] / crop_pct   ))
             else:
                 raise ValueError('''Invalid size for resize: {}'''.format(a   )   )

             __lowerCamelCase          =  get_resize_output_image_size(a  ,    size=a  ,    default_to_square=a   )
         else:
             if "shortest_edge" in size:
                 __lowerCamelCase          =  get_resize_output_image_size(a  ,    size=size['''shortest_edge''']  ,    default_to_square=a   )
             elif "height" in size and "width" in size:
                 __lowerCamelCase          =  (size['''height'''], size['''width'''])
             else:
                 raise ValueError('''Invalid size for resize: {}'''.format(a   )   )

         return resize(a  ,    size=a  ,    resample=a  ,    data_format=a  ,    **a   )






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





         """simple docstring"""



         __lowerCamelCase          =  get_size_dict(a   )
         if "height" not in size or "width" not in size:
             raise ValueError(f"""size must contain 'height' and 'width' as keys. Got {size.keys()}"""   )
         return center_crop(a  ,    size=(size['''height'''], size['''width'''])  ,    data_format=a  ,    **a   )






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





         """simple docstring"""



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






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





         """simple docstring"""



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






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





         """simple docstring"""



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

         __lowerCamelCase          =  size if size is not None else self.size
         __lowerCamelCase          =  get_size_dict(a  ,    default_to_square=a   )
         __lowerCamelCase          =  crop_size if crop_size is not None else self.crop_size
         __lowerCamelCase          =  get_size_dict(a  ,    param_name='''crop_size'''   )

         __lowerCamelCase          =  make_list_of_images(a   )

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

         if do_resize and size is None or resample is None:
             raise ValueError('''Size and resample must be specified if do_resize is True.'''   )

         if do_center_crop and crop_pct is None:
             raise ValueError('''Crop_pct 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.
         __lowerCamelCase          =  [to_numpy_array(a   ) for image in images]

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

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

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

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

         __lowerCamelCase          =  [to_channel_dimension_format(a  ,    a   ) for image in images]

         __lowerCamelCase          =  {'''pixel_values''': images}
         return BatchFeature(data=a  ,    tensor_type=a   )
