from typing import Dict, List, Optional, Tuple, 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, is_torch_available, is_torch_tensor, logging


if is_torch_available():
  import torch


SCREAMING_SNAKE_CASE			:						Optional[int]				  =		logging.get_logger(__name__)
class  A_			(							a_			):
  _SCREAMING_SNAKE_CASE     					=      ["""pixel_values"""]

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

  def 		_UpperCAmelCase (		self			:   int  ,				__SCREAMING_SNAKE_CASE			:   np.ndarray  ,				__SCREAMING_SNAKE_CASE			:   Dict[str, int]  ,				__SCREAMING_SNAKE_CASE			:   PILImageResampling = PILImageResampling.BICUBIC  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[str, ChannelDimension]] = None  ,				**__SCREAMING_SNAKE_CASE			:   List[Any]  ,				):
   __a							=	get_size_dict(__SCREAMING_SNAKE_CASE  ,				default_to_square=__SCREAMING_SNAKE_CASE							)
   if "shortest_edge" not in size:
    raise ValueError(f"""The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}"""							)
   __a							=	get_resize_output_image_size(__SCREAMING_SNAKE_CASE  ,				size=size["shortest_edge"]  ,				default_to_square=__SCREAMING_SNAKE_CASE							)
   return resize(__SCREAMING_SNAKE_CASE  ,				size=__SCREAMING_SNAKE_CASE  ,				resample=__SCREAMING_SNAKE_CASE  ,				data_format=__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   int  ,				__SCREAMING_SNAKE_CASE			:   np.ndarray  ,				__SCREAMING_SNAKE_CASE			:   Dict[str, int]  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[str, ChannelDimension]] = None  ,				**__SCREAMING_SNAKE_CASE			:   str  ,				):
   __a							=	get_size_dict(__SCREAMING_SNAKE_CASE							)
   if "height" not in size or "width" not in size:
    raise ValueError(f"""The `size` parameter must contain the keys `height` and `width`. Got {size.keys()}"""							)
   return center_crop(__SCREAMING_SNAKE_CASE  ,				size=(size["height"], size["width"])  ,				data_format=__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   List[Any]  ,				__SCREAMING_SNAKE_CASE			:   np.ndarray  ,				__SCREAMING_SNAKE_CASE			:   float  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[str, ChannelDimension]] = None  ,				**__SCREAMING_SNAKE_CASE			:   Union[str, Any]							):
   return rescale(__SCREAMING_SNAKE_CASE  ,				scale=__SCREAMING_SNAKE_CASE  ,				data_format=__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   List[str]  ,				__SCREAMING_SNAKE_CASE			:   np.ndarray  ,				__SCREAMING_SNAKE_CASE			:   Union[float, List[float]]  ,				__SCREAMING_SNAKE_CASE			:   Union[float, List[float]]  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[str, ChannelDimension]] = None  ,				**__SCREAMING_SNAKE_CASE			:   List[str]  ,				):
   return normalize(__SCREAMING_SNAKE_CASE  ,				mean=__SCREAMING_SNAKE_CASE  ,				std=__SCREAMING_SNAKE_CASE  ,				data_format=__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   int  ,				__SCREAMING_SNAKE_CASE			:   ImageInput  ,				__SCREAMING_SNAKE_CASE			:   Optional[bool] = None  ,				__SCREAMING_SNAKE_CASE			:   Dict[str, int] = None  ,				__SCREAMING_SNAKE_CASE			:   PILImageResampling = None  ,				__SCREAMING_SNAKE_CASE			:   bool = None  ,				__SCREAMING_SNAKE_CASE			:   Dict[str, int] = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[bool] = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[float] = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[bool] = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[float, List[float]]] = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[float, List[float]]] = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[str, TensorType]] = None  ,				__SCREAMING_SNAKE_CASE			:   Union[str, ChannelDimension] = ChannelDimension.FIRST  ,				**__SCREAMING_SNAKE_CASE			:   Any  ,				):
   __a							=	do_resize if do_resize is not None else self.do_resize
   __a							=	size if size is not None else self.size
   __a							=	get_size_dict(__SCREAMING_SNAKE_CASE  ,				default_to_square=__SCREAMING_SNAKE_CASE							)
   __a							=	resample if resample is not None else self.resample
   __a							=	do_center_crop if do_center_crop is not None else self.do_center_crop
   __a							=	crop_size if crop_size is not None else self.crop_size
   __a							=	get_size_dict(__SCREAMING_SNAKE_CASE  ,				param_name="crop_size"							)
   __a							=	do_rescale if do_rescale is not None else self.do_rescale
   __a							=	rescale_factor if rescale_factor is not None else self.rescale_factor
   __a							=	do_normalize if do_normalize is not None else self.do_normalize
   __a							=	image_mean if image_mean is not None else self.image_mean
   __a							=	image_std if image_std is not None else self.image_std

   __a							=	make_list_of_images(__SCREAMING_SNAKE_CASE							)

   if not valid_images(__SCREAMING_SNAKE_CASE							):
    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.
   __a							=	[to_numpy_array(__SCREAMING_SNAKE_CASE							) for image in images]

   if do_resize:
    __a							=	[self.resize(image=__SCREAMING_SNAKE_CASE  ,				size=__SCREAMING_SNAKE_CASE  ,				resample=__SCREAMING_SNAKE_CASE							) for image in images]

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

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

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

   __a							=	[to_channel_dimension_format(__SCREAMING_SNAKE_CASE  ,				__SCREAMING_SNAKE_CASE							) for image in images]

   __a							=	{"pixel_values": images}
   return BatchFeature(data=__SCREAMING_SNAKE_CASE  ,				tensor_type=__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   str  ,				__SCREAMING_SNAKE_CASE			:   int  ,				__SCREAMING_SNAKE_CASE			:   List[Tuple] = None							):
   __a							=	outputs.logits

   # Resize logits and compute semantic segmentation maps
   if target_sizes is not None:
    if len(__SCREAMING_SNAKE_CASE							) != len(__SCREAMING_SNAKE_CASE							):
     raise ValueError(
         "Make sure that you pass in as many target sizes as the batch dimension of the logits"							)

    if is_torch_tensor(__SCREAMING_SNAKE_CASE							):
     __a							=	target_sizes.numpy()

    __a							=	[]

    for idx in range(len(__SCREAMING_SNAKE_CASE							)							):
     __a							=	torch.nn.functional.interpolate(
         logits[idx].unsqueeze(dim=0							)  ,				size=target_sizes[idx]  ,				mode="bilinear"  ,				align_corners=__SCREAMING_SNAKE_CASE							)
     __a							=	resized_logits[0].argmax(dim=0							)
     semantic_segmentation.append(__SCREAMING_SNAKE_CASE							)
   else:
    __a							=	logits.argmax(dim=1							)
    __a							=	[semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]							)]

   return semantic_segmentation



import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
  from .tokenization_albert import AlbertTokenizer
else:
  SCREAMING_SNAKE_CASE			:						Any				  =		None

SCREAMING_SNAKE_CASE			:						str				  =		logging.get_logger(__name__)
SCREAMING_SNAKE_CASE			:						Optional[Any]				  =		{"""vocab_file""": """spiece.model""", """tokenizer_file""": """tokenizer.json"""}

SCREAMING_SNAKE_CASE			:						Optional[Any]				  =		{
    """vocab_file""": {
        """albert-base-v1""": """https://huggingface.co/albert-base-v1/resolve/main/spiece.model""",
        """albert-large-v1""": """https://huggingface.co/albert-large-v1/resolve/main/spiece.model""",
        """albert-xlarge-v1""": """https://huggingface.co/albert-xlarge-v1/resolve/main/spiece.model""",
        """albert-xxlarge-v1""": """https://huggingface.co/albert-xxlarge-v1/resolve/main/spiece.model""",
        """albert-base-v2""": """https://huggingface.co/albert-base-v2/resolve/main/spiece.model""",
        """albert-large-v2""": """https://huggingface.co/albert-large-v2/resolve/main/spiece.model""",
        """albert-xlarge-v2""": """https://huggingface.co/albert-xlarge-v2/resolve/main/spiece.model""",
        """albert-xxlarge-v2""": """https://huggingface.co/albert-xxlarge-v2/resolve/main/spiece.model""",
    },
    """tokenizer_file""": {
        """albert-base-v1""": """https://huggingface.co/albert-base-v1/resolve/main/tokenizer.json""",
        """albert-large-v1""": """https://huggingface.co/albert-large-v1/resolve/main/tokenizer.json""",
        """albert-xlarge-v1""": """https://huggingface.co/albert-xlarge-v1/resolve/main/tokenizer.json""",
        """albert-xxlarge-v1""": """https://huggingface.co/albert-xxlarge-v1/resolve/main/tokenizer.json""",
        """albert-base-v2""": """https://huggingface.co/albert-base-v2/resolve/main/tokenizer.json""",
        """albert-large-v2""": """https://huggingface.co/albert-large-v2/resolve/main/tokenizer.json""",
        """albert-xlarge-v2""": """https://huggingface.co/albert-xlarge-v2/resolve/main/tokenizer.json""",
        """albert-xxlarge-v2""": """https://huggingface.co/albert-xxlarge-v2/resolve/main/tokenizer.json""",
    },
}

SCREAMING_SNAKE_CASE			:						Any				  =		{
    """albert-base-v1""": 512,
    """albert-large-v1""": 512,
    """albert-xlarge-v1""": 512,
    """albert-xxlarge-v1""": 512,
    """albert-base-v2""": 512,
    """albert-large-v2""": 512,
    """albert-xlarge-v2""": 512,
    """albert-xxlarge-v2""": 512,
}

SCREAMING_SNAKE_CASE			:						Optional[int]				  =		"""▁"""
class  A_			(							a_			):
  _SCREAMING_SNAKE_CASE     					=      VOCAB_FILES_NAMES
  _SCREAMING_SNAKE_CASE     					=      PRETRAINED_VOCAB_FILES_MAP
  _SCREAMING_SNAKE_CASE     					=      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  _SCREAMING_SNAKE_CASE     					=      AlbertTokenizer

  def __init__(		self			:   List[Any]  ,				__SCREAMING_SNAKE_CASE			:   Union[str, Any]=None  ,				__SCREAMING_SNAKE_CASE			:   int=None  ,				__SCREAMING_SNAKE_CASE			:   Dict=True  ,				__SCREAMING_SNAKE_CASE			:   Tuple=True  ,				__SCREAMING_SNAKE_CASE			:   Dict=False  ,				__SCREAMING_SNAKE_CASE			:   Dict="[CLS]"  ,				__SCREAMING_SNAKE_CASE			:   Union[str, Any]="[SEP]"  ,				__SCREAMING_SNAKE_CASE			:   Dict="<unk>"  ,				__SCREAMING_SNAKE_CASE			:   str="[SEP]"  ,				__SCREAMING_SNAKE_CASE			:   Any="<pad>"  ,				__SCREAMING_SNAKE_CASE			:   List[str]="[CLS]"  ,				__SCREAMING_SNAKE_CASE			:   Optional[int]="[MASK]"  ,				**__SCREAMING_SNAKE_CASE			:   Tuple  ,				):
   # Mask token behave like a normal word, i.e. include the space before it and
   # is included in the raw text, there should be a match in a non-normalized sentence.
   __a							=	(
       AddedToken(__SCREAMING_SNAKE_CASE  ,				lstrip=__SCREAMING_SNAKE_CASE  ,				rstrip=__SCREAMING_SNAKE_CASE  ,				normalized=__SCREAMING_SNAKE_CASE							)
       if isinstance(__SCREAMING_SNAKE_CASE  ,				__SCREAMING_SNAKE_CASE							)
       else mask_token
   )

   super().__init__(
       __SCREAMING_SNAKE_CASE  ,				tokenizer_file=__SCREAMING_SNAKE_CASE  ,				do_lower_case=__SCREAMING_SNAKE_CASE  ,				remove_space=__SCREAMING_SNAKE_CASE  ,				keep_accents=__SCREAMING_SNAKE_CASE  ,				bos_token=__SCREAMING_SNAKE_CASE  ,				eos_token=__SCREAMING_SNAKE_CASE  ,				unk_token=__SCREAMING_SNAKE_CASE  ,				sep_token=__SCREAMING_SNAKE_CASE  ,				pad_token=__SCREAMING_SNAKE_CASE  ,				cls_token=__SCREAMING_SNAKE_CASE  ,				mask_token=__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE  ,				)

   __a							=	do_lower_case
   __a							=	remove_space
   __a							=	keep_accents
   __a							=	vocab_file
   __a							=	False if not self.vocab_file else True

  def 		_UpperCAmelCase (		self			:   List[str]  ,				__SCREAMING_SNAKE_CASE			:   List[int]  ,				__SCREAMING_SNAKE_CASE			:   Optional[List[int]] = None							):
   __a							=	[self.sep_token_id]
   __a							=	[self.cls_token_id]
   if token_ids_a is None:
    return cls + token_ids_a + sep
   return cls + token_ids_a + sep + token_ids_a + sep

  def 		_UpperCAmelCase (		self			:   Any  ,				__SCREAMING_SNAKE_CASE			:   List[int]  ,				__SCREAMING_SNAKE_CASE			:   Optional[List[int]] = None							):
   __a							=	[self.sep_token_id]
   __a							=	[self.cls_token_id]

   if token_ids_a is None:
    return len(cls + token_ids_a + sep							) * [0]
   return len(cls + token_ids_a + sep							) * [0] + len(token_ids_a + sep							) * [1]

  def 		_UpperCAmelCase (		self			:   Union[str, Any]  ,				__SCREAMING_SNAKE_CASE			:   str  ,				__SCREAMING_SNAKE_CASE			:   Optional[str] = None							):
   if not self.can_save_slow_tokenizer:
    raise ValueError(
        "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
        "tokenizer."							)

   if not os.path.isdir(__SCREAMING_SNAKE_CASE							):
    logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""							)
    return
   __a							=	os.path.join(
       __SCREAMING_SNAKE_CASE  ,				(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]							)

   if os.path.abspath(self.vocab_file							) != os.path.abspath(__SCREAMING_SNAKE_CASE							):
    copyfile(self.vocab_file  ,				__SCREAMING_SNAKE_CASE							)

   return (out_vocab_file,)


