



"""simple docstring"""




import json
from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_mvp import MvpTokenizer


_lowerCAmelCase							:   Optional[Any]				=				logging.get_logger(__name__)


_lowerCAmelCase							:   int				=				{"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"}

# See all MVP models at https://huggingface.co/models?filter=mvp
_lowerCAmelCase							:   Optional[int]				=				{
    "vocab_file": {
        "RUCAIBox/mvp": "https://huggingface.co/RUCAIBox/mvp/resolve/main/vocab.json",
    },
    "added_tokens.json": {
        "RUCAIBox/mvp": "https://huggingface.co/RUCAIBox/mvp/resolve/main/added_tokens.json",
    },
    "merges_file": {
        "RUCAIBox/mvp": "https://huggingface.co/RUCAIBox/mvp/resolve/main/merges.txt",
    },
    "tokenizer_file": {
        "RUCAIBox/mvp": "https://huggingface.co/RUCAIBox/mvp/resolve/main/tokenizer.json",
    },
}

_lowerCAmelCase							:   List[str]				=				{
    "RUCAIBox/mvp": 10_24,
}






class       UpperCAmelCase_    (							_UpperCamelCase		):
      __SCREAMING_SNAKE_CASE		:  Optional[Any]						=					VOCAB_FILES_NAMES
      __SCREAMING_SNAKE_CASE		:  Optional[Any]						=					PRETRAINED_VOCAB_FILES_MAP
      __SCREAMING_SNAKE_CASE		:  Union[str, Any]						=					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      __SCREAMING_SNAKE_CASE		:  List[Any]						=					['input_ids', 'attention_mask']
      __SCREAMING_SNAKE_CASE		:  Dict						=					MvpTokenizer



      def __init__(	self	:      Union[str, Any]	,      A	:      str=None	,      A	:      List[str]=None	,      A	:      Tuple=None	,      A	:      List[str]="replace"	,      A	:      Optional[Any]="<s>"	,      A	:      Optional[int]="</s>"	,      A	:      Dict="</s>"	,      A	:      str="<s>"	,      A	:      List[str]="<unk>"	,      A	:      Tuple="<pad>"	,      A	:      Dict="<mask>"	,      A	:      int=False	,      A	:      Union[str, Any]=True	,      **A	:      Optional[int]	,      ):
           super().__init__(
               A	,      A	,      tokenizer_file=A	,      errors=A	,      bos_token=A	,      eos_token=A	,      sep_token=A	,      cls_token=A	,      unk_token=A	,      pad_token=A	,      mask_token=A	,      add_prefix_space=A	,      trim_offsets=A	,      **A	,      )

           _UpperCAmelCase     :      Tuple														=       json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()		)
           if pre_tok_state.get("add_prefix_space"	,      A		) != add_prefix_space:
                _UpperCAmelCase     :      int														=       getattr(A	,      pre_tok_state.pop("type"		)		)
                _UpperCAmelCase     :      Union[str, Any]														=       add_prefix_space
                _UpperCAmelCase     :      List[Any]														=       pre_tok_class(**A		)

           _UpperCAmelCase     :      Union[str, Any]														=       add_prefix_space

           # the pre_tokenizer is already updated in the GPT2TokenizerFast `__init__`
           _UpperCAmelCase     :      Optional[Any]														=       "post_processor"
           _UpperCAmelCase     :      Optional[Any]														=       getattr(self.backend_tokenizer	,      A	,      A		)
           if tokenizer_component_instance:
                _UpperCAmelCase     :      Any														=       json.loads(tokenizer_component_instance.__getstate__()		)

                # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
                if "sep" in state:
                     _UpperCAmelCase     :      Dict														=       tuple(state["sep"]		)
                if "cls" in state:
                     _UpperCAmelCase     :      Optional[Any]														=       tuple(state["cls"]		)

                _UpperCAmelCase     :      Optional[int]														=       False

                if state.get("add_prefix_space"	,      A		) != add_prefix_space:
                     _UpperCAmelCase     :      Any														=       add_prefix_space
                     _UpperCAmelCase     :      Dict														=       True

                if state.get("trim_offsets"	,      A		) != trim_offsets:
                     _UpperCAmelCase     :      Tuple														=       trim_offsets
                     _UpperCAmelCase     :      Dict														=       True

                if changes_to_apply:
                     _UpperCAmelCase     :      Any														=       getattr(A	,      state.pop("type"		)		)
                     _UpperCAmelCase     :      Tuple														=       component_class(**A		)
                     setattr(self.backend_tokenizer	,      A	,      A		)



      @property
      def 		snake_case_   (	self	:      Dict		):
           if self._mask_token is None:
                if self.verbose:
                     logger.error("Using mask_token, but it is not set yet."		)
                return None
           return str(self._mask_token		)



      @mask_token.setter
      def 		snake_case_   (	self	:      Any	,      A	:      int		):
           _UpperCAmelCase     :      List[Any]														=       AddedToken(A	,      lstrip=A	,      rstrip=A		) if isinstance(A	,      A		) else value
           _UpperCAmelCase     :      Dict														=       value



      def 		snake_case_   (	self	:      Optional[Any]	,      *A	:      List[Any]	,      **A	:      Union[str, Any]		):
           _UpperCAmelCase     :      Optional[int]														=       kwargs.get("is_split_into_words"	,      A		)

           if is_split_into_words and not self.add_prefix_space:
                raise ValueError(
                    f'You need to instantiate {self.__class__.__name__} with add_prefix_space=True '
                    "to use it with pretokenized inputs."		)

           return super()._batch_encode_plus(*A	,      **A		)



      def 		snake_case_   (	self	:      Optional[Any]	,      *A	:      Optional[Any]	,      **A	:      int		):
           _UpperCAmelCase     :      Any														=       kwargs.get("is_split_into_words"	,      A		)

           if is_split_into_words and not self.add_prefix_space:
                raise ValueError(
                    f'You need to instantiate {self.__class__.__name__} with add_prefix_space=True '
                    "to use it with pretokenized inputs."		)

           return super()._encode_plus(*A	,      **A		)



      def 		snake_case_   (	self	:      int	,      A	:      str	,      A	:      Optional[str] = None		):
           _UpperCAmelCase     :      Optional[int]														=       self._tokenizer.model.save(A	,      name=A		)
           return tuple(A		)



      def 		snake_case_   (	self	:      Optional[Any]	,      A	:      Union[str, Any]	,      A	:      Tuple=None		):
           _UpperCAmelCase     :      Any														=       [self.bos_token_id] + token_ids_a + [self.eos_token_id]
           if token_ids_a is None:
                return output

           return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]



      def 		snake_case_   (	self	:      List[Any]	,      A	:      List[int]	,      A	:      Optional[List[int]] = None		):
           _UpperCAmelCase     :      Dict														=       [self.sep_token_id]
           _UpperCAmelCase     :      Tuple														=       [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 + sep + token_ids_a + sep		) * [0]





"""simple docstring"""




import inspect
import unittest

from transformers import MobileViTVaConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel
 from transformers.models.mobilevitva.modeling_mobilevitva import (
     MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
     make_divisible,
 )


if is_vision_available():
 from PIL import Image

 from transformers import MobileViTImageProcessor






class       UpperCAmelCase_    (							_UpperCamelCase		):



      def 		snake_case_   (	self	:      str		):
           _UpperCAmelCase     :      Dict														=       self.config_class(**self.inputs_dict		)
           self.parent.assertTrue(hasattr(A	,      "width_multiplier"		)		)







class       UpperCAmelCase_    :



      def __init__(	self	:      Dict	,      A	:      Union[str, Any]	,      A	:      Dict=1_3	,      A	:      Union[str, Any]=6_4	,      A	:      int=2	,      A	:      Tuple=3	,      A	:      int="swish"	,      A	:      Optional[int]=3	,      A	:      Tuple=3_2	,      A	:      Tuple=0.1	,      A	:      List[Any]=0.02	,      A	:      Dict=True	,      A	:      str=True	,      A	:      Any=1_0	,      A	:      Optional[int]=None	,      A	:      int=0.25	,      A	:      int=0.0	,      A	:      Dict=0.0	,      ):
           _UpperCAmelCase     :      List[Any]														=       parent
           _UpperCAmelCase     :      Optional[Any]														=       batch_size
           _UpperCAmelCase     :      Dict														=       image_size
           _UpperCAmelCase     :      int														=       patch_size
           _UpperCAmelCase     :      List[str]														=       num_channels
           _UpperCAmelCase     :      Optional[int]														=       make_divisible(5_1_2 * width_multiplier	,      divisor=8		)
           _UpperCAmelCase     :      Dict														=       hidden_act
           _UpperCAmelCase     :      List[str]														=       conv_kernel_size
           _UpperCAmelCase     :      Optional[int]														=       output_stride
           _UpperCAmelCase     :      Union[str, Any]														=       classifier_dropout_prob
           _UpperCAmelCase     :      str														=       use_labels
           _UpperCAmelCase     :      Dict														=       is_training
           _UpperCAmelCase     :      Optional[int]														=       num_labels
           _UpperCAmelCase     :      Tuple														=       initializer_range
           _UpperCAmelCase     :      Tuple														=       scope
           _UpperCAmelCase     :      List[Any]														=       width_multiplier
           _UpperCAmelCase     :      List[str]														=       ffn_dropout
           _UpperCAmelCase     :      List[Any]														=       attn_dropout



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase     :      Optional[Any]														=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

           _UpperCAmelCase     :      str														=       None
           _UpperCAmelCase     :      List[Any]														=       None
           if self.use_labels:
                _UpperCAmelCase     :      Dict														=       ids_tensor([self.batch_size]	,      self.num_labels		)
                _UpperCAmelCase     :      List[Any]														=       ids_tensor([self.batch_size, self.image_size, self.image_size]	,      self.num_labels		)

           _UpperCAmelCase     :      Optional[int]														=       self.get_config()

           return config, pixel_values, labels, pixel_labels



      def 		snake_case_   (	self	:      List[Any]		):
           return MobileViTVaConfig(
               image_size=self.image_size	,      patch_size=self.patch_size	,      num_channels=self.num_channels	,      hidden_act=self.hidden_act	,      conv_kernel_size=self.conv_kernel_size	,      output_stride=self.output_stride	,      classifier_dropout_prob=self.classifier_dropout_prob	,      initializer_range=self.initializer_range	,      width_multiplier=self.width_multiplier	,      ffn_dropout=self.ffn_dropout_prob	,      attn_dropout=self.attn_dropout_prob	,      )



      def 		snake_case_   (	self	:      int	,      A	:      Optional[Any]	,      A	:      Optional[int]	,      A	:      Any	,      A	:      int		):
           _UpperCAmelCase     :      List[str]														=       MobileViTVaModel(config=A		)
           model.to(A		)
           model.eval()
           _UpperCAmelCase     :      str														=       model(A		)
           self.parent.assertEqual(
               result.last_hidden_state.shape	,      (
                   self.batch_size,
                   self.last_hidden_size,
                   self.image_size // self.output_stride,
                   self.image_size // self.output_stride,
               )	,      )



      def 		snake_case_   (	self	:      Any	,      A	:      Optional[int]	,      A	:      Optional[Any]	,      A	:      str	,      A	:      List[str]		):
           _UpperCAmelCase     :      List[str]														=       self.num_labels
           _UpperCAmelCase     :      int														=       MobileViTVaForImageClassification(A		)
           model.to(A		)
           model.eval()
           _UpperCAmelCase     :      str														=       model(A	,      labels=A		)
           self.parent.assertEqual(result.logits.shape	,      (self.batch_size, self.num_labels)		)



      def 		snake_case_   (	self	:      Optional[int]	,      A	:      Tuple	,      A	:      Any	,      A	:      Any	,      A	:      Optional[Any]		):
           _UpperCAmelCase     :      Union[str, Any]														=       self.num_labels
           _UpperCAmelCase     :      Optional[int]														=       MobileViTVaForSemanticSegmentation(A		)
           model.to(A		)
           model.eval()
           _UpperCAmelCase     :      List[str]														=       model(A		)
           self.parent.assertEqual(
               result.logits.shape	,      (
                   self.batch_size,
                   self.num_labels,
                   self.image_size // self.output_stride,
                   self.image_size // self.output_stride,
               )	,      )
           _UpperCAmelCase     :      Optional[int]														=       model(A	,      labels=A		)
           self.parent.assertEqual(
               result.logits.shape	,      (
                   self.batch_size,
                   self.num_labels,
                   self.image_size // self.output_stride,
                   self.image_size // self.output_stride,
               )	,      )



      def 		snake_case_   (	self	:      Any		):
           _UpperCAmelCase     :      Any														=       self.prepare_config_and_inputs()
           _UpperCAmelCase							,			_UpperCAmelCase							,			_UpperCAmelCase							,			_UpperCAmelCase     :      str														=       config_and_inputs
           _UpperCAmelCase     :      str														=       {"pixel_values": pixel_values}
           return config, inputs_dict







@require_torch
class       UpperCAmelCase_    (							_UpperCamelCase			,     _UpperCamelCase			,     unittest.TestCase		):
      __SCREAMING_SNAKE_CASE		:  Tuple						=					(
          (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
          if is_torch_available()
          else ()
      )

      __SCREAMING_SNAKE_CASE		:  Optional[Any]						=					(
          {
              'feature-extraction': MobileViTVaModel,
              'image-classification': MobileViTVaForImageClassification,
              'image-segmentation': MobileViTVaForSemanticSegmentation,
          }
          if is_torch_available()
          else {}
      )

      __SCREAMING_SNAKE_CASE		:  str						=					False
      __SCREAMING_SNAKE_CASE		:  List[Any]						=					False
      __SCREAMING_SNAKE_CASE		:  Dict						=					False
      __SCREAMING_SNAKE_CASE		:  Union[str, Any]						=					False



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase     :      Dict														=       MobileViTVaModelTester(self		)
           _UpperCAmelCase     :      Optional[Any]														=       MobileViTVaConfigTester(self	,      config_class=A	,      has_text_modality=A		)



      def 		snake_case_   (	self	:      int		):
           self.config_tester.run_common_tests()



      @unittest.skip(reason="MobileViTV2 does not use inputs_embeds"		)
      def 		snake_case_   (	self	:      Optional[int]		):
           pass



      @unittest.skip(reason="MobileViTV2 does not support input and output embeddings"		)
      def 		snake_case_   (	self	:      Optional[Any]		):
           pass



      @unittest.skip(reason="MobileViTV2 does not output attentions"		)
      def 		snake_case_   (	self	:      int		):
           pass



      @require_torch_multi_gpu
      @unittest.skip(reason="Got `CUDA error: misaligned address` for tests after this one being run."		)
      def 		snake_case_   (	self	:      Any		):
           pass



      @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."		)
      def 		snake_case_   (	self	:      str		):
           pass



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase							,			_UpperCAmelCase     :      Optional[Any]														=       self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                _UpperCAmelCase     :      Union[str, Any]														=       model_class(A		)
                _UpperCAmelCase     :      str														=       inspect.signature(model.forward		)
                # signature.parameters is an OrderedDict => so arg_names order is deterministic
                _UpperCAmelCase     :      int														=       [*signature.parameters.keys()]

                _UpperCAmelCase     :      Optional[Any]														=       ["pixel_values"]
                self.assertListEqual(arg_names[:1]	,      A		)



      def 		snake_case_   (	self	:      int		):
           _UpperCAmelCase     :      Union[str, Any]														=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*A		)



      def 		snake_case_   (	self	:      Optional[Any]		):
           def check_hidden_states_output(A	:      Union[str, Any]	,      A	:      Dict	,      A	:      str		):
                _UpperCAmelCase     :      int														=       model_class(A		)
                model.to(A		)
                model.eval()

                with torch.no_grad():
                     _UpperCAmelCase     :      Tuple														=       model(**self._prepare_for_class(A	,      A		)		)

                _UpperCAmelCase     :      List[str]														=       outputs.hidden_states

                _UpperCAmelCase     :      int														=       5
                self.assertEqual(len(A		)	,      A		)

                # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
                # with the width and height being successively divided by 2.
                _UpperCAmelCase     :      Optional[int]														=       2
                for i in range(len(A		)		):
                     self.assertListEqual(
                         list(hidden_states[i].shape[-2:]		)	,      [self.model_tester.image_size // divisor, self.model_tester.image_size // divisor]	,      )
                     divisor *= 2

                self.assertEqual(self.model_tester.output_stride	,      divisor // 2		)

           _UpperCAmelCase							,			_UpperCAmelCase     :      List[Any]														=       self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                _UpperCAmelCase     :      Optional[Any]														=       True
                check_hidden_states_output(A	,      A	,      A		)

                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                _UpperCAmelCase     :      str														=       True

                check_hidden_states_output(A	,      A	,      A		)



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase     :      List[str]														=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*A		)



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase     :      int														=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_semantic_segmentation(*A		)



      @slow
      def 		snake_case_   (	self	:      int		):
           for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                _UpperCAmelCase     :      Union[str, Any]														=       MobileViTVaModel.from_pretrained(A		)
                self.assertIsNotNone(A		)







def 		__snake_case		( )    ->  Optional[Any]:





     '''simple docstring'''

     _UpperCAmelCase     :      Any														=       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"							)
     return image






@require_torch
@require_vision
class       UpperCAmelCase_    (							unittest.TestCase		):



      @cached_property
      def 		snake_case_   (	self	:      Any		):
           return (
               MobileViTImageProcessor.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256"		)
               if is_vision_available()
               else None
           )



      @slow
      def 		snake_case_   (	self	:      Dict		):
           _UpperCAmelCase     :      Dict														=       MobileViTVaForImageClassification.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256"		).to(
               A		)

           _UpperCAmelCase     :      Optional[Any]														=       self.default_image_processor
           _UpperCAmelCase     :      Tuple														=       prepare_img()
           _UpperCAmelCase     :      Union[str, Any]														=       image_processor(images=A	,      return_tensors="pt"		).to(A		)

           # forward pass
           with torch.no_grad():
                _UpperCAmelCase     :      Tuple														=       model(**A		)

           # verify the logits
           _UpperCAmelCase     :      Tuple														=       torch.Size((1, 1_0_0_0)		)
           self.assertEqual(outputs.logits.shape	,      A		)

           _UpperCAmelCase     :      Optional[Any]														=       torch.tensor([-1.6336e00, -7.3204e-02, -5.1883e-01]		).to(A		)

           self.assertTrue(torch.allclose(outputs.logits[0, :3]	,      A	,      atol=1e-4		)		)



      @slow
      def 		snake_case_   (	self	:      Optional[int]		):
           _UpperCAmelCase     :      List[Any]														=       MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"		)
           _UpperCAmelCase     :      Any														=       model.to(A		)

           _UpperCAmelCase     :      Optional[Any]														=       MobileViTImageProcessor.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"		)

           _UpperCAmelCase     :      Dict														=       prepare_img()
           _UpperCAmelCase     :      Union[str, Any]														=       image_processor(images=A	,      return_tensors="pt"		).to(A		)

           # forward pass
           with torch.no_grad():
                _UpperCAmelCase     :      int														=       model(**A		)
           _UpperCAmelCase     :      Any														=       outputs.logits

           # verify the logits
           _UpperCAmelCase     :      Optional[int]														=       torch.Size((1, 2_1, 3_2, 3_2)		)
           self.assertEqual(logits.shape	,      A		)

           _UpperCAmelCase     :      Union[str, Any]														=       torch.tensor(
               [
                   [[7.0_863, 7.1_525, 6.8_201], [6.6_931, 6.8_770, 6.8_933], [6.2_978, 7.0_366, 6.9_636]],
                   [[-3.7_134, -3.6_712, -3.6_675], [-3.5_825, -3.3_549, -3.4_777], [-3.3_435, -3.3_979, -3.2_857]],
                   [[-2.9_329, -2.8_003, -2.7_369], [-3.0_564, -2.4_780, -2.0_207], [-2.6_889, -1.9_298, -1.7_640]],
               ]	,      device=A	,      )

           self.assertTrue(torch.allclose(logits[0, :3, :3, :3]	,      A	,      atol=1e-4		)		)



      @slow
      def 		snake_case_   (	self	:      List[str]		):
           _UpperCAmelCase     :      List[str]														=       MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"		)
           _UpperCAmelCase     :      Tuple														=       model.to(A		)

           _UpperCAmelCase     :      Dict														=       MobileViTImageProcessor.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"		)

           _UpperCAmelCase     :      Optional[int]														=       prepare_img()
           _UpperCAmelCase     :      Optional[int]														=       image_processor(images=A	,      return_tensors="pt"		).to(A		)

           # forward pass
           with torch.no_grad():
                _UpperCAmelCase     :      Tuple														=       model(**A		)

           _UpperCAmelCase     :      Optional[int]														=       outputs.logits.detach().cpu()

           _UpperCAmelCase     :      List[Any]														=       image_processor.post_process_semantic_segmentation(outputs=A	,      target_sizes=[(5_0, 6_0)]		)
           _UpperCAmelCase     :      Dict														=       torch.Size((5_0, 6_0)		)
           self.assertEqual(segmentation[0].shape	,      A		)

           _UpperCAmelCase     :      Dict														=       image_processor.post_process_semantic_segmentation(outputs=A		)
           _UpperCAmelCase     :      Union[str, Any]														=       torch.Size((3_2, 3_2)		)
           self.assertEqual(segmentation[0].shape	,      A		)
