import os
import unittest

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    BertTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english
@require_tokenizers
class SCREAMING_SNAKE_CASE_						(	_UpperCAmelCase   ,			unittest.TestCase						):
   __lowerCAmelCase      =							BertTokenizer
   __lowerCAmelCase      =							BertTokenizerFast
   __lowerCAmelCase      =							True
   __lowerCAmelCase      =							True
   __lowerCAmelCase      =							filter_non_english







   def 		lowerCamelCase_     (			self		:		List[str]							):





    """simple docstring"""


    super().setUp()

    UpperCamelCase          =	[
        '''[UNK]''',
        '''[CLS]''',
        '''[SEP]''',
        '''[PAD]''',
        '''[MASK]''',
        '''want''',
        '''##want''',
        '''##ed''',
        '''wa''',
        '''un''',
        '''runn''',
        '''##ing''',
        ''',''',
        '''low''',
        '''lowest''',
    ]
    UpperCamelCase          =	os.path.join(self.tmpdirname					,					VOCAB_FILES_NAMES["""vocab_file"""]							)
    with open(self.vocab_file					,					"""w"""					,					encoding="""utf-8"""							) as vocab_writer:
     vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]							)							)







   def 		lowerCamelCase_     (			self		:		Optional[int]					,					lowerCamelCase_		:		Tuple							):





    """simple docstring"""


    UpperCamelCase          =	'''UNwant\u00E9d,running'''
    UpperCamelCase          =	'''unwanted, running'''
    return input_text, output_text







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





    """simple docstring"""


    UpperCamelCase          =	self.tokenizer_class(self.vocab_file							)

    UpperCamelCase          =	tokenizer.tokenize("""UNwant\u00E9d,running"""							)
    self.assertListEqual(A_					,					["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""]							)
    self.assertListEqual(tokenizer.convert_tokens_to_ids(A_							)					,					[9, 6, 7, 12, 10, 11]							)







   def 		lowerCamelCase_     (			self		:		Optional[Any]							):





    """simple docstring"""


    if not self.test_rust_tokenizer:
     return

    UpperCamelCase          =	self.get_tokenizer()
    UpperCamelCase          =	self.get_rust_tokenizer()

    UpperCamelCase          =	'''UNwant\u00E9d,running'''

    UpperCamelCase          =	tokenizer.tokenize(A_							)
    UpperCamelCase          =	rust_tokenizer.tokenize(A_							)
    self.assertListEqual(A_					,					A_							)

    UpperCamelCase          =	tokenizer.encode(A_					,					add_special_tokens=A_							)
    UpperCamelCase          =	rust_tokenizer.encode(A_					,					add_special_tokens=A_							)
    self.assertListEqual(A_					,					A_							)

    UpperCamelCase          =	self.get_rust_tokenizer()
    UpperCamelCase          =	tokenizer.encode(A_							)
    UpperCamelCase          =	rust_tokenizer.encode(A_							)
    self.assertListEqual(A_					,					A_							)

    # With lower casing
    UpperCamelCase          =	self.get_tokenizer(do_lower_case=A_							)
    UpperCamelCase          =	self.get_rust_tokenizer(do_lower_case=A_							)

    UpperCamelCase          =	'''UNwant\u00E9d,running'''

    UpperCamelCase          =	tokenizer.tokenize(A_							)
    UpperCamelCase          =	rust_tokenizer.tokenize(A_							)
    self.assertListEqual(A_					,					A_							)

    UpperCamelCase          =	tokenizer.encode(A_					,					add_special_tokens=A_							)
    UpperCamelCase          =	rust_tokenizer.encode(A_					,					add_special_tokens=A_							)
    self.assertListEqual(A_					,					A_							)

    UpperCamelCase          =	self.get_rust_tokenizer()
    UpperCamelCase          =	tokenizer.encode(A_							)
    UpperCamelCase          =	rust_tokenizer.encode(A_							)
    self.assertListEqual(A_					,					A_							)







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





    """simple docstring"""


    UpperCamelCase          =	BasicTokenizer()

    self.assertListEqual(tokenizer.tokenize("""ah\u535A\u63A8zz"""							)					,					["""ah""", """\u535A""", """\u63A8""", """zz"""]							)







   def 		lowerCamelCase_     (			self		:		Optional[int]							):





    """simple docstring"""


    UpperCamelCase          =	BasicTokenizer(do_lower_case=A_							)

    self.assertListEqual(
        tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU?  """							)					,					["""hello""", """!""", """how""", """are""", """you""", """?"""]							)
    self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""							)					,					["""hello"""]							)







   def 		lowerCamelCase_     (			self		:		Dict							):





    """simple docstring"""


    UpperCamelCase          =	BasicTokenizer(do_lower_case=A_					,					strip_accents=A_							)

    self.assertListEqual(
        tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """							)					,					["""hällo""", """!""", """how""", """are""", """you""", """?"""]							)
    self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""							)					,					["""h\u00E9llo"""]							)







   def 		lowerCamelCase_     (			self		:		List[str]							):





    """simple docstring"""


    UpperCamelCase          =	BasicTokenizer(do_lower_case=A_					,					strip_accents=A_							)

    self.assertListEqual(
        tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """							)					,					["""hallo""", """!""", """how""", """are""", """you""", """?"""]							)
    self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""							)					,					["""hello"""]							)







   def 		lowerCamelCase_     (			self		:		str							):





    """simple docstring"""


    UpperCamelCase          =	BasicTokenizer(do_lower_case=A_							)

    self.assertListEqual(
        tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """							)					,					["""hallo""", """!""", """how""", """are""", """you""", """?"""]							)
    self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""							)					,					["""hello"""]							)







   def 		lowerCamelCase_     (			self		:		str							):





    """simple docstring"""


    UpperCamelCase          =	BasicTokenizer(do_lower_case=A_							)

    self.assertListEqual(
        tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU?  """							)					,					["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?"""]							)







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





    """simple docstring"""


    UpperCamelCase          =	BasicTokenizer(do_lower_case=A_					,					strip_accents=A_							)

    self.assertListEqual(
        tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """							)					,					["""HäLLo""", """!""", """how""", """Are""", """yoU""", """?"""]							)







   def 		lowerCamelCase_     (			self		:		List[str]							):





    """simple docstring"""


    UpperCamelCase          =	BasicTokenizer(do_lower_case=A_					,					strip_accents=A_							)

    self.assertListEqual(
        tokenizer.tokenize(""" \tHäLLo!how  \n Are yoU?  """							)					,					["""HaLLo""", """!""", """how""", """Are""", """yoU""", """?"""]							)







   def 		lowerCamelCase_     (			self		:		Dict							):





    """simple docstring"""


    UpperCamelCase          =	BasicTokenizer(do_lower_case=A_					,					never_split=["""[UNK]"""]							)

    self.assertListEqual(
        tokenizer.tokenize(""" \tHeLLo!how  \n Are yoU? [UNK]"""							)					,					["""HeLLo""", """!""", """how""", """Are""", """yoU""", """?""", """[UNK]"""]							)







   def 		lowerCamelCase_     (			self		:		Tuple							):





    """simple docstring"""


    UpperCamelCase          =	BasicTokenizer()
    UpperCamelCase          =	'''a\n\'ll !!to?\'d of, can\'t.'''
    UpperCamelCase          =	['''a''', '''\'''', '''ll''', '''!''', '''!''', '''to''', '''?''', '''\'''', '''d''', '''of''', ''',''', '''can''', '''\'''', '''t''', '''.''']
    self.assertListEqual(tokenizer.tokenize(A_							)					,					A_							)







   def 		lowerCamelCase_     (			self		:		Optional[int]							):





    """simple docstring"""


    UpperCamelCase          =	['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

    UpperCamelCase          =	{}
    for i, token in enumerate(A_							):
     UpperCamelCase          =	i
    UpperCamelCase          =	WordpieceTokenizer(vocab=A_					,					unk_token="""[UNK]"""							)

    self.assertListEqual(tokenizer.tokenize(""""""							)					,					[]							)

    self.assertListEqual(tokenizer.tokenize("""unwanted running"""							)					,					["""un""", """##want""", """##ed""", """runn""", """##ing"""]							)

    self.assertListEqual(tokenizer.tokenize("""unwantedX running"""							)					,					["""[UNK]""", """runn""", """##ing"""]							)







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





    """simple docstring"""


    self.assertTrue(_is_whitespace(""" """							)							)
    self.assertTrue(_is_whitespace("""\t"""							)							)
    self.assertTrue(_is_whitespace("""\r"""							)							)
    self.assertTrue(_is_whitespace("""\n"""							)							)
    self.assertTrue(_is_whitespace("""\u00A0"""							)							)

    self.assertFalse(_is_whitespace("""A"""							)							)
    self.assertFalse(_is_whitespace("""-"""							)							)







   def 		lowerCamelCase_     (			self		:		Optional[int]							):





    """simple docstring"""


    self.assertTrue(_is_control("""\u0005"""							)							)

    self.assertFalse(_is_control("""A"""							)							)
    self.assertFalse(_is_control(""" """							)							)
    self.assertFalse(_is_control("""\t"""							)							)
    self.assertFalse(_is_control("""\r"""							)							)







   def 		lowerCamelCase_     (			self		:		Any							):





    """simple docstring"""


    self.assertTrue(_is_punctuation("""-"""							)							)
    self.assertTrue(_is_punctuation("""$"""							)							)
    self.assertTrue(_is_punctuation("""`"""							)							)
    self.assertTrue(_is_punctuation("""."""							)							)

    self.assertFalse(_is_punctuation("""A"""							)							)
    self.assertFalse(_is_punctuation(""" """							)							)







   def 		lowerCamelCase_     (			self		:		int							):





    """simple docstring"""


    UpperCamelCase          =	self.get_tokenizer()
    UpperCamelCase          =	self.get_rust_tokenizer()

    # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
    self.assertListEqual([tokenizer.tokenize(A_							) for t in ["""Test""", """\xad""", """test"""]]					,					[["""[UNK]"""], [], ["""[UNK]"""]]							)

    self.assertListEqual(
        [rust_tokenizer.tokenize(A_							) for t in ["""Test""", """\xad""", """test"""]]					,					[["""[UNK]"""], [], ["""[UNK]"""]]							)







   @slow
   def 		lowerCamelCase_     (			self		:		int							):





    """simple docstring"""


    UpperCamelCase          =	self.tokenizer_class.from_pretrained("""bert-base-uncased"""							)

    UpperCamelCase          =	tokenizer.encode("""sequence builders"""					,					add_special_tokens=A_							)
    UpperCamelCase          =	tokenizer.encode("""multi-sequence build"""					,					add_special_tokens=A_							)

    UpperCamelCase          =	tokenizer.build_inputs_with_special_tokens(A_							)
    UpperCamelCase          =	tokenizer.build_inputs_with_special_tokens(A_					,					A_							)

    assert encoded_sentence == [101] + text + [102]
    assert encoded_pair == [101] + text + [102] + text_a + [102]







   def 		lowerCamelCase_     (			self		:		List[Any]							):





    """simple docstring"""


    for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
     with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""							):
      UpperCamelCase          =	self.rust_tokenizer_class.from_pretrained(A_					,					**A_							)

      UpperCamelCase          =	f"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
      UpperCamelCase          =	tokenizer_r.encode_plus(
          A_					,					return_attention_mask=A_					,					return_token_type_ids=A_					,					return_offsets_mapping=A_					,					add_special_tokens=A_					,					)

      UpperCamelCase          =	tokenizer_r.do_lower_case if hasattr(A_					,					"""do_lower_case"""							) else False
      UpperCamelCase          =	(
          [
              ((0, 0), tokenizer_r.cls_token),
              ((0, 1), '''A'''),
              ((1, 2), ''','''),
              ((3, 5), '''na'''),
              ((5, 6), '''##ï'''),
              ((6, 8), '''##ve'''),
              ((9, 15), tokenizer_r.mask_token),
              ((16, 21), '''Allen'''),
              ((21, 23), '''##NL'''),
              ((23, 24), '''##P'''),
              ((25, 33), '''sentence'''),
              ((33, 34), '''.'''),
              ((0, 0), tokenizer_r.sep_token),
          ]
          if not do_lower_case
          else [
              ((0, 0), tokenizer_r.cls_token),
              ((0, 1), '''a'''),
              ((1, 2), ''','''),
              ((3, 8), '''naive'''),
              ((9, 15), tokenizer_r.mask_token),
              ((16, 21), '''allen'''),
              ((21, 23), '''##nl'''),
              ((23, 24), '''##p'''),
              ((25, 33), '''sentence'''),
              ((33, 34), '''.'''),
              ((0, 0), tokenizer_r.sep_token),
          ]
      )

      self.assertEqual(
          [e[1] for e in expected_results]					,					tokenizer_r.convert_ids_to_tokens(tokens["""input_ids"""]							)							)
      self.assertEqual([e[0] for e in expected_results]					,					tokens["""offset_mapping"""]							)







   def 		lowerCamelCase_     (			self		:		List[str]							):





    """simple docstring"""


    UpperCamelCase          =	['''的''', '''人''', '''有''']
    UpperCamelCase          =	''''''.join(A_							)
    for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
     with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""							):
      UpperCamelCase          =	True
      UpperCamelCase          =	self.tokenizer_class.from_pretrained(A_					,					**A_							)
      UpperCamelCase          =	self.rust_tokenizer_class.from_pretrained(A_					,					**A_							)

      UpperCamelCase          =	tokenizer_p.encode(A_					,					add_special_tokens=A_							)
      UpperCamelCase          =	tokenizer_r.encode(A_					,					add_special_tokens=A_							)

      UpperCamelCase          =	tokenizer_r.convert_ids_to_tokens(A_							)
      UpperCamelCase          =	tokenizer_p.convert_ids_to_tokens(A_							)

      # it is expected that each Chinese character is not preceded by "##"
      self.assertListEqual(A_					,					A_							)
      self.assertListEqual(A_					,					A_							)

      UpperCamelCase          =	False
      UpperCamelCase          =	self.rust_tokenizer_class.from_pretrained(A_					,					**A_							)
      UpperCamelCase          =	self.tokenizer_class.from_pretrained(A_					,					**A_							)

      UpperCamelCase          =	tokenizer_r.encode(A_					,					add_special_tokens=A_							)
      UpperCamelCase          =	tokenizer_p.encode(A_					,					add_special_tokens=A_							)

      UpperCamelCase          =	tokenizer_r.convert_ids_to_tokens(A_							)
      UpperCamelCase          =	tokenizer_p.convert_ids_to_tokens(A_							)

      # it is expected that only the first Chinese character is not preceded by "##".
      UpperCamelCase          =	[
          f"""##{token}""" if idx != 0 else token for idx, token in enumerate(A_							)
      ]
      self.assertListEqual(A_					,					A_							)
      self.assertListEqual(A_					,					A_							)



import math
from typing import Dict, Iterable, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    is_torch_available,
    is_torch_tensor,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_torch_available():
 import torch

if is_vision_available():
 import PIL


_UpperCamelCase 			=		logging.get_logger(__name__)







def 		_lowercase (     lowercase__   ,	lowercase__   ,	lowercase__   ,	lowercase__						):
      def constraint_to_multiple_of(lowercase__   ,	lowercase__   ,	lowercase__=0   ,	lowercase__=None						):
            __lowerCAmelCase					:						int					=					round(val / multiple						) * multiple

            if max_val is not None and x > max_val:
                  __lowerCAmelCase					:						Optional[int]					=					math.floor(val / multiple						) * multiple

            if x < min_val:
                  __lowerCAmelCase					:						Any					=					math.ceil(val / multiple						) * multiple

            return x

      __lowerCAmelCase					:						Dict					=					(output_size, output_size) if isinstance(lowercase__   ,	lowercase__						) else output_size

      __lowerCAmelCase,							__lowerCAmelCase					:						Optional[Any]					=					get_image_size(lowercase__						)
      __lowerCAmelCase,							__lowerCAmelCase					:						int					=					output_size

      # determine new height and width
      __lowerCAmelCase					:						Optional[Any]					=					output_height / input_height
      __lowerCAmelCase					:						List[Any]					=					output_width / input_width

      if keep_aspect_ratio:
            # scale as little as possible
            if abs(1 - scale_width						) < abs(1 - scale_height						):
                  # fit width
                  __lowerCAmelCase					:						str					=					scale_width
            else:
                  # fit height
                  __lowerCAmelCase					:						str					=					scale_height

      __lowerCAmelCase					:						Any					=					constraint_to_multiple_of(scale_height * input_height   ,	multiple=lowercase__						)
      __lowerCAmelCase					:						Union[str, Any]					=					constraint_to_multiple_of(scale_width * input_width   ,	multiple=lowercase__						)

      return (new_height, new_width)







class   __lowercase      (_UpperCAmelCase ):
 _UpperCamelCase			  =  ["""pixel_values"""]
 def __init__(							self      ,							A_ = True      ,							A_ = None      ,							A_ = PILImageResampling.BILINEAR      ,							A_ = False      ,							A_ = 1      ,							A_ = True      ,							A_ = 1 / 255      ,							A_ = True      ,							A_ = None      ,							A_ = None      ,							**A_      ,							)					->None:



       '''simple docstring'''





       super().__init__(**A_					)
       __lowerCAmelCase					:						Union[str, Any]					=					size if size is not None else {'''height''': 384, '''width''': 384}
       __lowerCAmelCase					:						Dict					=					get_size_dict(A_					)
       __lowerCAmelCase					:						Optional[Any]					=					do_resize
       __lowerCAmelCase					:						int					=					size
       __lowerCAmelCase					:						Dict					=					keep_aspect_ratio
       __lowerCAmelCase					:						List[Any]					=					ensure_multiple_of
       __lowerCAmelCase					:						Tuple					=					resample
       __lowerCAmelCase					:						Dict					=					do_rescale
       __lowerCAmelCase					:						Any					=					rescale_factor
       __lowerCAmelCase					:						List[Any]					=					do_normalize
       __lowerCAmelCase					:						Optional[int]					=					image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
       __lowerCAmelCase					:						Optional[int]					=					image_std if image_std is not None else IMAGENET_STANDARD_STD
 def 	UpperCamelCase__  (							self      ,							A_      ,							A_      ,							A_ = False      ,							A_ = 1      ,							A_ = PILImageResampling.BICUBIC      ,							A_ = None      ,							**A_      ,							)					->np.ndarray:



       '''simple docstring'''





       __lowerCAmelCase					:						int					=					get_size_dict(A_					)
       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()}"""					)
       __lowerCAmelCase					:						Union[str, Any]					=					get_resize_output_image_size(
           A_      ,							output_size=(size['''height'''], size['''width'''])      ,							keep_aspect_ratio=A_      ,							multiple=A_      ,							)
       return resize(A_      ,							size=A_      ,							resample=A_      ,							data_format=A_      ,							**A_					)
 def 	UpperCamelCase__  (							self      ,							A_      ,							A_      ,							A_ = None      ,							**A_      ,							)					->Dict:



       '''simple docstring'''





       return rescale(A_      ,							scale=A_      ,							data_format=A_      ,							**A_					)
 def 	UpperCamelCase__  (							self      ,							A_      ,							A_      ,							A_      ,							A_ = None      ,							**A_      ,							)					->np.ndarray:



       '''simple docstring'''





       return normalize(A_      ,							mean=A_      ,							std=A_      ,							data_format=A_      ,							**A_					)
 def 	UpperCamelCase__  (							self      ,							A_      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = None      ,							A_ = ChannelDimension.FIRST      ,							**A_      ,							)					->PIL.Image.Image:



       '''simple docstring'''





       __lowerCAmelCase					:						int					=					do_resize if do_resize is not None else self.do_resize
       __lowerCAmelCase					:						Optional[int]					=					size if size is not None else self.size
       __lowerCAmelCase					:						Union[str, Any]					=					get_size_dict(A_					)
       __lowerCAmelCase					:						List[Any]					=					keep_aspect_ratio if keep_aspect_ratio is not None else self.keep_aspect_ratio
       __lowerCAmelCase					:						Optional[int]					=					ensure_multiple_of if ensure_multiple_of is not None else self.ensure_multiple_of
       __lowerCAmelCase					:						Tuple					=					resample if resample is not None else self.resample
       __lowerCAmelCase					:						Optional[int]					=					do_rescale if do_rescale is not None else self.do_rescale
       __lowerCAmelCase					:						Union[str, Any]					=					rescale_factor if rescale_factor is not None else self.rescale_factor
       __lowerCAmelCase					:						Tuple					=					do_normalize if do_normalize is not None else self.do_normalize
       __lowerCAmelCase					:						str					=					image_mean if image_mean is not None else self.image_mean
       __lowerCAmelCase					:						Optional[Any]					=					image_std if image_std is not None else self.image_std

       __lowerCAmelCase					:						Optional[Any]					=					make_list_of_images(A_					)

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

       if do_resize and size is None or resample is None:
             raise ValueError('''Size and resample 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 std must be specified if do_normalize is True.'''					)

       # All transformations expect numpy arrays.
       __lowerCAmelCase					:						Any					=					[to_numpy_array(A_					) for image in images]

       if do_resize:
             __lowerCAmelCase					:						Optional[Any]					=					[self.resize(image=A_      ,							size=A_      ,							resample=A_					) for image in images]

       if do_rescale:
             __lowerCAmelCase					:						Tuple					=					[self.rescale(image=A_      ,							scale=A_					) for image in images]

       if do_normalize:
             __lowerCAmelCase					:						str					=					[self.normalize(image=A_      ,							mean=A_      ,							std=A_					) for image in images]

       __lowerCAmelCase					:						Union[str, Any]					=					[to_channel_dimension_format(A_      ,							A_					) for image in images]

       __lowerCAmelCase					:						Dict					=					{'''pixel_values''': images}
       return BatchFeature(data=A_      ,							tensor_type=A_					)





 def 	UpperCamelCase__  (							self      ,							A_      ,							A_ = None					)					->Any:



       '''simple docstring'''





       __lowerCAmelCase					:						Any					=					outputs.logits

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

             if is_torch_tensor(A_					):
                   __lowerCAmelCase					:						Optional[int]					=					target_sizes.numpy()

             __lowerCAmelCase					:						List[str]					=					[]

             for idx in range(len(A_					)					):
                   __lowerCAmelCase					:						Any					=					torch.nn.functional.interpolate(
                       logits[idx].unsqueeze(dim=0					)      ,							size=target_sizes[idx]      ,							mode='''bilinear'''      ,							align_corners=A_					)
                   __lowerCAmelCase					:						str					=					resized_logits[0].argmax(dim=0					)
                   semantic_segmentation.append(A_					)
       else:
             __lowerCAmelCase					:						Any					=					logits.argmax(dim=1					)
             __lowerCAmelCase					:						List[Any]					=					[semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]					)]

       return semantic_segmentation


