code: 
  
  
  
  
  
  import os
  import unittest
  
  from transformers import ElectraTokenizerFast
  from transformers.models.electra.tokenization_electra import (
      VOCAB_FILES_NAMES,
      BasicTokenizer,
      ElectraTokenizer,
      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 				_lowerCamelCase (    a ,   unittest.TestCase    ):
  
  
  
        """simple docstring"""
  
  
  
  
  
  
        UpperCAmelCase_						:      Optional[Any]       =ElectraTokenizer
        UpperCAmelCase_						:      Any       =ElectraTokenizerFast
        UpperCAmelCase_						:      Optional[Any]       =True
        UpperCAmelCase_						:      Tuple       =True
        UpperCAmelCase_						:      Tuple       =filter_non_english
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   str:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          super().setUp()
  
          __snake_case   :				int        =       [
              "[UNK]",
              "[CLS]",
              "[SEP]",
              "[PAD]",
              "[MASK]",
              "want",
              "##want",
              "##ed",
              "wa",
              "un",
              "runn",
              "##ing",
              ",",
              "low",
              "lowest",
          ]
          __snake_case   :				int        =       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 						UpperCAmelCase		( self				,						UpperCAmelCase   )       ->   Tuple:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				int        =       "UNwant\u00E9d,running"
          __snake_case   :				Dict        =       "unwanted, running"
          return input_text, output_text
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   Any:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Union[str, Any]        =       self.tokenizer_class(self.vocab_file   )
  
          __snake_case   :				int        =       tokenizer.tokenize("UNwant\u00E9d,running"   )
          self.assertListEqual(UpperCAmelCase				,						["un", "##want", "##ed", ",", "runn", "##ing"]   )
          self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase   )				,						[9, 6, 7, 12, 10, 11]   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   str:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          if not self.test_rust_tokenizer:
            return
  
          __snake_case   :				Any        =       self.get_tokenizer()
          __snake_case   :				Dict        =       self.get_rust_tokenizer()
  
          __snake_case   :				str        =       "UNwant\u00E9d,running"
  
          __snake_case   :				Tuple        =       tokenizer.tokenize(UpperCAmelCase   )
          __snake_case   :				Optional[Any]        =       rust_tokenizer.tokenize(UpperCAmelCase   )
          self.assertListEqual(UpperCAmelCase				,						UpperCAmelCase   )
  
          __snake_case   :				str        =       tokenizer.encode(UpperCAmelCase				,						add_special_tokens=UpperCAmelCase   )
          __snake_case   :				str        =       rust_tokenizer.encode(UpperCAmelCase				,						add_special_tokens=UpperCAmelCase   )
          self.assertListEqual(UpperCAmelCase				,						UpperCAmelCase   )
  
          __snake_case   :				Optional[Any]        =       self.get_rust_tokenizer()
          __snake_case   :				List[Any]        =       tokenizer.encode(UpperCAmelCase   )
          __snake_case   :				Optional[int]        =       rust_tokenizer.encode(UpperCAmelCase   )
          self.assertListEqual(UpperCAmelCase				,						UpperCAmelCase   )
  
          # With lower casing
          __snake_case   :				Union[str, Any]        =       self.get_tokenizer(do_lower_case=UpperCAmelCase   )
          __snake_case   :				Dict        =       self.get_rust_tokenizer(do_lower_case=UpperCAmelCase   )
  
          __snake_case   :				Any        =       "UNwant\u00E9d,running"
  
          __snake_case   :				Tuple        =       tokenizer.tokenize(UpperCAmelCase   )
          __snake_case   :				Optional[Any]        =       rust_tokenizer.tokenize(UpperCAmelCase   )
          self.assertListEqual(UpperCAmelCase				,						UpperCAmelCase   )
  
          __snake_case   :				str        =       tokenizer.encode(UpperCAmelCase				,						add_special_tokens=UpperCAmelCase   )
          __snake_case   :				Optional[Any]        =       rust_tokenizer.encode(UpperCAmelCase				,						add_special_tokens=UpperCAmelCase   )
          self.assertListEqual(UpperCAmelCase				,						UpperCAmelCase   )
  
          __snake_case   :				List[Any]        =       self.get_rust_tokenizer()
          __snake_case   :				List[str]        =       tokenizer.encode(UpperCAmelCase   )
          __snake_case   :				Any        =       rust_tokenizer.encode(UpperCAmelCase   )
          self.assertListEqual(UpperCAmelCase				,						UpperCAmelCase   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   Union[str, Any]:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Any        =       BasicTokenizer()
  
          self.assertListEqual(tokenizer.tokenize("ah\u535A\u63A8zz"   )				,						["ah", "\u535A", "\u63A8", "zz"]   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   Dict:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				str        =       BasicTokenizer(do_lower_case=UpperCAmelCase   )
  
          self.assertListEqual(
              tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "   )				,						["hello", "!", "how", "are", "you", "?"]   )
          self.assertListEqual(tokenizer.tokenize("H\u00E9llo"   )				,						["hello"]   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   List[Any]:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				int        =       BasicTokenizer(do_lower_case=UpperCAmelCase				,						strip_accents=UpperCAmelCase   )
  
          self.assertListEqual(
              tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   )				,						["hällo", "!", "how", "are", "you", "?"]   )
          self.assertListEqual(tokenizer.tokenize("H\u00E9llo"   )				,						["h\u00E9llo"]   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   Optional[Any]:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Dict        =       BasicTokenizer(do_lower_case=UpperCAmelCase				,						strip_accents=UpperCAmelCase   )
  
          self.assertListEqual(
              tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   )				,						["hallo", "!", "how", "are", "you", "?"]   )
          self.assertListEqual(tokenizer.tokenize("H\u00E9llo"   )				,						["hello"]   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   Any:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				List[Any]        =       BasicTokenizer(do_lower_case=UpperCAmelCase   )
  
          self.assertListEqual(
              tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   )				,						["hallo", "!", "how", "are", "you", "?"]   )
          self.assertListEqual(tokenizer.tokenize("H\u00E9llo"   )				,						["hello"]   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   Tuple:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Union[str, Any]        =       BasicTokenizer(do_lower_case=UpperCAmelCase   )
  
          self.assertListEqual(
              tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "   )				,						["HeLLo", "!", "how", "Are", "yoU", "?"]   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   Union[str, Any]:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Optional[Any]        =       BasicTokenizer(do_lower_case=UpperCAmelCase				,						strip_accents=UpperCAmelCase   )
  
          self.assertListEqual(
              tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   )				,						["HäLLo", "!", "how", "Are", "yoU", "?"]   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   int:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				str        =       BasicTokenizer(do_lower_case=UpperCAmelCase				,						strip_accents=UpperCAmelCase   )
  
          self.assertListEqual(
              tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   )				,						["HaLLo", "!", "how", "Are", "yoU", "?"]   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   Union[str, Any]:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				int        =       BasicTokenizer(do_lower_case=UpperCAmelCase				,						never_split=["[UNK]"]   )
  
          self.assertListEqual(
              tokenizer.tokenize(" \tHeLLo!how  \n Are yoU? [UNK]"   )				,						["HeLLo", "!", "how", "Are", "yoU", "?", "[UNK]"]   )
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   List[Any]:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Union[str, Any]        =       ["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]
  
          __snake_case   :				Tuple        =       {}
          for i, token in enumerate(UpperCAmelCase   ):
            __snake_case   :				str        =       i
          __snake_case   :				Any        =       WordpieceTokenizer(vocab=UpperCAmelCase				,						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 						UpperCAmelCase		( self   )       ->   Dict:
  
  
  
  
  
  
          '''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 						UpperCAmelCase		( self   )       ->   Any:
  
  
  
  
  
  
          '''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 						UpperCAmelCase		( self   )       ->   Union[str, 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 						UpperCAmelCase		( self   )       ->   List[Any]:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Tuple        =       self.get_tokenizer()
          __snake_case   :				Dict        =       self.get_rust_tokenizer()
  
          # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
          self.assertListEqual([tokenizer.tokenize(UpperCAmelCase   ) for t in ["Test", "\xad", "test"]]				,						[["[UNK]"], [], ["[UNK]"]]   )
  
          self.assertListEqual(
              [rust_tokenizer.tokenize(UpperCAmelCase   ) for t in ["Test", "\xad", "test"]]				,						[["[UNK]"], [], ["[UNK]"]]   )
  
  
  
  
  
  
  
        @slow
        def 						UpperCAmelCase		( self   )       ->   Dict:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				List[str]        =       self.tokenizer_class.from_pretrained("google/electra-base-discriminator"   )
  
          __snake_case   :				Dict        =       tokenizer.encode("sequence builders"				,						add_special_tokens=UpperCAmelCase   )
          __snake_case   :				Optional[Any]        =       tokenizer.encode("multi-sequence build"				,						add_special_tokens=UpperCAmelCase   )
  
          __snake_case   :				str        =       tokenizer.build_inputs_with_special_tokens(UpperCAmelCase   )
          __snake_case   :				Tuple        =       tokenizer.build_inputs_with_special_tokens(UpperCAmelCase				,						UpperCAmelCase   )
  
          assert encoded_sentence == [101] + text + [102]
          assert encoded_pair == [101] + text + [102] + text_a + [102]
  
  
  
  
  
  
  
        def 						UpperCAmelCase		( self   )       ->   str:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""   ):
              __snake_case   :				Any        =       self.rust_tokenizer_class.from_pretrained(UpperCAmelCase				,						**UpperCAmelCase   )
  
              __snake_case   :				Optional[Any]        =       F"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
              __snake_case   :				Union[str, Any]        =       tokenizer_r.encode_plus(
                  UpperCAmelCase				,						return_attention_mask=UpperCAmelCase				,						return_token_type_ids=UpperCAmelCase				,						return_offsets_mapping=UpperCAmelCase				,						add_special_tokens=UpperCAmelCase				,						)
  
              __snake_case   :				Optional[int]        =       tokenizer_r.do_lower_case if hasattr(UpperCAmelCase				,						"do_lower_case"   ) else False
              __snake_case   :				Tuple        =       (
                  [
                      ((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 						UpperCAmelCase		( self   )       ->   Dict:
  
  
  
  
  
  
          '''simple docstring'''
  
  
  
  
  
  
          __snake_case   :				Union[str, Any]        =       ["的", "人", "有"]
          __snake_case   :				Optional[int]        =       "".join(UpperCAmelCase   )
          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""   ):
              __snake_case   :				List[Any]        =       True
              __snake_case   :				str        =       self.tokenizer_class.from_pretrained(UpperCAmelCase				,						**UpperCAmelCase   )
              __snake_case   :				Tuple        =       self.rust_tokenizer_class.from_pretrained(UpperCAmelCase				,						**UpperCAmelCase   )
  
              __snake_case   :				Union[str, Any]        =       tokenizer_p.encode(UpperCAmelCase				,						add_special_tokens=UpperCAmelCase   )
              __snake_case   :				Optional[Any]        =       tokenizer_r.encode(UpperCAmelCase				,						add_special_tokens=UpperCAmelCase   )
  
              __snake_case   :				Any        =       tokenizer_r.convert_ids_to_tokens(UpperCAmelCase   )
              __snake_case   :				Any        =       tokenizer_p.convert_ids_to_tokens(UpperCAmelCase   )
  
              # it is expected that each Chinese character is not preceded by "##"
              self.assertListEqual(UpperCAmelCase				,						UpperCAmelCase   )
              self.assertListEqual(UpperCAmelCase				,						UpperCAmelCase   )
  
              __snake_case   :				Tuple        =       False
              __snake_case   :				Tuple        =       self.rust_tokenizer_class.from_pretrained(UpperCAmelCase				,						**UpperCAmelCase   )
              __snake_case   :				List[str]        =       self.tokenizer_class.from_pretrained(UpperCAmelCase				,						**UpperCAmelCase   )
  
              __snake_case   :				Optional[Any]        =       tokenizer_r.encode(UpperCAmelCase				,						add_special_tokens=UpperCAmelCase   )
              __snake_case   :				Optional[Any]        =       tokenizer_p.encode(UpperCAmelCase				,						add_special_tokens=UpperCAmelCase   )
  
              __snake_case   :				List[Any]        =       tokenizer_r.convert_ids_to_tokens(UpperCAmelCase   )
              __snake_case   :				Union[str, Any]        =       tokenizer_p.convert_ids_to_tokens(UpperCAmelCase   )
  
              # it is expected that only the first Chinese character is not preceded by "##".
              __snake_case   :				Optional[int]        =       [
                  F"""##{token}""" if idx != 0 else token for idx, token in enumerate(UpperCAmelCase   )
              ]
              self.assertListEqual(UpperCAmelCase				,						UpperCAmelCase   )
              self.assertListEqual(UpperCAmelCase				,						UpperCAmelCase   )
  
  
style_context: 
  
  
  
  
  
  import argparse
  import json
  import re
  from pathlib import Path
  
  import requests
  import torch
  from huggingface_hub import hf_hub_download
  from PIL import Image
  
  from transformers import (
      MobileNetVaConfig,
      MobileNetVaForImageClassification,
      MobileNetVaForSemanticSegmentation,
      MobileNetVaImageProcessor,
      load_tf_weights_in_mobilenet_va,
  )
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  _UpperCamelCase       = logging.get_logger(__name__)
  
  
  
  
  
  
  
  def       lowerCAmelCase__(	lowercase       :    Dict				) ->    Union[str, Any]:
    __snake_case   :				List[str]        =       MobileNetVaConfig(layer_norm_eps=0.0_0_1				)
  
    if "quant" in model_name:
      raise ValueError("Quantized models are not supported."				)
  
    __snake_case   :				Dict        =       re.match(R"^.*mobilenet_v2_([^_]*)_([^_]*)$"   ,     lowercase				)
    if matches:
      __snake_case   :				Tuple        =       float(matches[1]				)
      __snake_case   :				List[Any]        =       int(matches[2]				)
  
    if model_name.startswith("deeplabv3_"				):
      __snake_case   :				Any        =       8
      __snake_case   :				Any        =       21
      __snake_case   :				Optional[Any]        =       "pascal-voc-id2label.json"
    else:
      # The TensorFlow version of MobileNetV2 predicts 1001 classes instead
      # of the usual 1000. The first class (index 0) is "background".
      __snake_case   :				Optional[Any]        =       1001
      __snake_case   :				str        =       "imagenet-1k-id2label.json"
  
    __snake_case   :				Any        =       "huggingface/label-files"
    __snake_case   :				str        =       json.load(open(hf_hub_download(lowercase   ,     lowercase   ,     repo_type="dataset"				)   ,     "r"				)				)
  
    if config.num_labels == 1001:
      __snake_case   :				Optional[Any]        =       {int(lowercase				) + 1: v for k, v in idalabel.items()}
      __snake_case   :				Any        =       "background"
    else:
      __snake_case   :				Optional[Any]        =       {int(lowercase				): v for k, v in idalabel.items()}
  
    __snake_case   :				Any        =       idalabel
    __snake_case   :				List[str]        =       {v: k for k, v in idalabel.items()}
  
    return config
  
  
  
  
  
  
  
  def       lowerCAmelCase__(	) ->    Optional[Any]:
    __snake_case   :				List[Any]        =       "http://images.cocodataset.org/val2017/000000039769.jpg"
    __snake_case   :				Union[str, Any]        =       Image.open(requests.get(lowercase   ,     stream=lowercase				).raw				)
    return im
  
  
  
  
  
  
  
  @torch.no_grad()
  def       lowerCAmelCase__(	lowercase       :    str   ,     lowercase       :    List[str]   ,     lowercase       :    int   ,     lowercase       :    List[str]=False				) ->    str:
    __snake_case   :				Dict        =       get_mobilenet_va_config(lowercase				)
  
    # Load 🤗 model
    if model_name.startswith("deeplabv3_"				):
      __snake_case   :				str        =       MobileNetVaForSemanticSegmentation(lowercase				).eval()
    else:
      __snake_case   :				Any        =       MobileNetVaForImageClassification(lowercase				).eval()
  
    # Load weights from TensorFlow checkpoint
    load_tf_weights_in_mobilenet_va(lowercase   ,     lowercase   ,     lowercase				)
  
    # Check outputs on an image, prepared by MobileNetV2ImageProcessor
    __snake_case   :				List[str]        =       MobileNetVaImageProcessor(
        crop_size={"width": config.image_size, "height": config.image_size}   ,     size={"shortest_edge": config.image_size + 32}   ,     )
    __snake_case   :				Any        =       image_processor(images=prepare_img()   ,     return_tensors="pt"				)
    __snake_case   :				Dict        =       model(**lowercase				)
    __snake_case   :				List[Any]        =       outputs.logits
  
    if model_name.startswith("deeplabv3_"				):
      assert logits.shape == (1, 21, 65, 65)
  
      if model_name == "deeplabv3_mobilenet_v2_1.0_513":
        __snake_case   :				Any        =       torch.tensor(
            [
                [[1_7.5_7_9_0, 1_7.7_5_8_1, 1_8.3_3_5_5], [1_8.3_2_5_7, 1_8.4_2_3_0, 1_8.8_9_7_3], [1_8.6_1_6_9, 1_8.8_6_5_0, 1_9.2_1_8_7]],
                [[-2.1_5_9_5, -2.0_9_7_7, -2.3_7_4_1], [-2.4_2_2_6, -2.3_0_2_8, -2.6_8_3_5], [-2.7_8_1_9, -2.5_9_9_1, -2.7_7_0_6]],
                [[4.2_0_5_8, 4.8_3_1_7, 4.7_6_3_8], [4.4_1_3_6, 5.0_3_6_1, 4.9_3_8_3], [4.5_0_2_8, 4.9_6_4_4, 4.8_7_3_4]],
            ]				)
  
      else:
        raise ValueError(f"""Unknown model name: {model_name}"""				)
  
      assert torch.allclose(logits[0, :3, :3, :3]   ,     lowercase   ,     atol=1E-4				)
    else:
      assert logits.shape == (1, 1001)
  
      if model_name == "mobilenet_v2_1.4_224":
        __snake_case   :				List[str]        =       torch.tensor([0.0_1_8_1, -1.0_0_1_5, 0.4_6_8_8]				)
      elif model_name == "mobilenet_v2_1.0_224":
        __snake_case   :				str        =       torch.tensor([0.2_4_4_5, -1.1_9_9_3, 0.1_9_0_5]				)
      elif model_name == "mobilenet_v2_0.75_160":
        __snake_case   :				Dict        =       torch.tensor([0.2_4_8_2, 0.4_1_3_6, 0.6_6_6_9]				)
      elif model_name == "mobilenet_v2_0.35_96":
        __snake_case   :				List[Any]        =       torch.tensor([0.1_4_5_1, -0.4_6_2_4, 0.7_1_9_2]				)
      else:
        __snake_case   :				int        =       None
  
      if expected_logits is not None:
        assert torch.allclose(logits[0, :3]   ,     lowercase   ,     atol=1E-4				)
  
    Path(lowercase				).mkdir(exist_ok=lowercase				)
    print(f"""Saving model {model_name} to {pytorch_dump_folder_path}"""				)
    model.save_pretrained(lowercase				)
    print(f"""Saving image processor to {pytorch_dump_folder_path}"""				)
    image_processor.save_pretrained(lowercase				)
  
    if push_to_hub:
      print("Pushing to the hub..."				)
      __snake_case   :				Optional[Any]        =       "google/" + model_name
      image_processor.push_to_hub(lowercase				)
      model.push_to_hub(lowercase				)
  
  
  if __name__ == "__main__":
       _UpperCamelCase       = argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           '''--model_name''',
           default='''mobilenet_v2_1.0_224''',
           type=str,
           help='''Name of the MobileNetV2 model you\'d like to convert. Should in the form \'mobilenet_v2_<depth>_<size>\'.''',
       )
       parser.add_argument(
           '''--checkpoint_path''', required=True, type=str, help='''Path to the original TensorFlow checkpoint (.ckpt file).'''
       )
       parser.add_argument(
           '''--pytorch_dump_folder_path''', required=True, 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_movilevit_checkpoint(
           args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
       )
  
  