



import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_url
from PIL import Image

from transformers import DPTConfig, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
a_			=					logging.get_logger(__name__)



def 		a__			(		_UpperCamelCase			: Union[str, Any]							):
   __lowerCamelCase													=    DPTConfig(embedding_type='''hybrid'''							)

   if "large" in checkpoint_url:
      __lowerCamelCase													=    10_24
      __lowerCamelCase													=    40_96
      __lowerCamelCase													=    24
      __lowerCamelCase													=    16
      __lowerCamelCase													=    [5, 11, 17, 23]
      __lowerCamelCase													=    [2_56, 5_12, 10_24, 10_24]
      __lowerCamelCase													=    (1, 3_84, 3_84)

   if "nyu" or "midas" in checkpoint_url:
      __lowerCamelCase													=    7_68
      __lowerCamelCase													=    [1, 1, 1, 0.5]
      __lowerCamelCase													=    [2_56, 5_12, 7_68, 7_68]
      __lowerCamelCase													=    1_50
      __lowerCamelCase													=    16
      __lowerCamelCase													=    (1, 3_84, 3_84)
      __lowerCamelCase													=    False
      __lowerCamelCase													=    "project"

   if "ade" in checkpoint_url:
      __lowerCamelCase													=    True
      __lowerCamelCase													=    7_68
      __lowerCamelCase													=    [1, 1, 1, 0.5]
      __lowerCamelCase													=    1_50
      __lowerCamelCase													=    16
      __lowerCamelCase													=    "huggingface/label-files"
      __lowerCamelCase													=    "ade20k-id2label.json"
      __lowerCamelCase													=    json.load(open(cached_download(hf_hub_url(_A ,_A ,repo_type='''dataset'''							)							) ,'''r'''							)							)
      __lowerCamelCase													=    {int(_A							): v for k, v in idalabel.items()}
      __lowerCamelCase													=    idalabel
      __lowerCamelCase													=    {v: k for k, v in idalabel.items()}
      __lowerCamelCase													=    [1, 1_50, 4_80, 4_80]

   return config, expected_shape



def 		a__			(		_UpperCamelCase			: List[str]							):
   __lowerCamelCase													=    ["pretrained.model.head.weight", "pretrained.model.head.bias"]
   for k in ignore_keys:
      state_dict.pop(_A ,_A							)



def 		a__			(		_UpperCamelCase			: Optional[Any]							):




   if (
       "pretrained.model" in name
       and "cls_token" not in name
       and "pos_embed" not in name
       and "patch_embed" not in name
   ):
      __lowerCamelCase													=    name.replace('''pretrained.model''' ,'''dpt.encoder'''							)
   if "pretrained.model" in name:
      __lowerCamelCase													=    name.replace('''pretrained.model''' ,'''dpt.embeddings'''							)
   if "patch_embed" in name:
      __lowerCamelCase													=    name.replace('''patch_embed''' ,''''''							)
   if "pos_embed" in name:
      __lowerCamelCase													=    name.replace('''pos_embed''' ,'''position_embeddings'''							)
   if "attn.proj" in name:
      __lowerCamelCase													=    name.replace('''attn.proj''' ,'''attention.output.dense'''							)
   if "proj" in name and "project" not in name:
      __lowerCamelCase													=    name.replace('''proj''' ,'''projection'''							)
   if "blocks" in name:
      __lowerCamelCase													=    name.replace('''blocks''' ,'''layer'''							)
   if "mlp.fc1" in name:
      __lowerCamelCase													=    name.replace('''mlp.fc1''' ,'''intermediate.dense'''							)
   if "mlp.fc2" in name:
      __lowerCamelCase													=    name.replace('''mlp.fc2''' ,'''output.dense'''							)
   if "norm1" in name and "backbone" not in name:
      __lowerCamelCase													=    name.replace('''norm1''' ,'''layernorm_before'''							)
   if "norm2" in name and "backbone" not in name:
      __lowerCamelCase													=    name.replace('''norm2''' ,'''layernorm_after'''							)
   if "scratch.output_conv" in name:
      __lowerCamelCase													=    name.replace('''scratch.output_conv''' ,'''head'''							)
   if "scratch" in name:
      __lowerCamelCase													=    name.replace('''scratch''' ,'''neck'''							)
   if "layer1_rn" in name:
      __lowerCamelCase													=    name.replace('''layer1_rn''' ,'''convs.0'''							)
   if "layer2_rn" in name:
      __lowerCamelCase													=    name.replace('''layer2_rn''' ,'''convs.1'''							)
   if "layer3_rn" in name:
      __lowerCamelCase													=    name.replace('''layer3_rn''' ,'''convs.2'''							)
   if "layer4_rn" in name:
      __lowerCamelCase													=    name.replace('''layer4_rn''' ,'''convs.3'''							)
   if "refinenet" in name:
      __lowerCamelCase													=    int(name[len('''neck.refinenet'''							) : len('''neck.refinenet'''							) + 1]							)
      # tricky here: we need to map 4 to 0, 3 to 1, 2 to 2 and 1 to 3
      __lowerCamelCase													=    name.replace(F"""refinenet{layer_idx}""" ,F"""fusion_stage.layers.{abs(layer_idx-4							)}"""							)
   if "out_conv" in name:
      __lowerCamelCase													=    name.replace('''out_conv''' ,'''projection'''							)
   if "resConfUnit1" in name:
      __lowerCamelCase													=    name.replace('''resConfUnit1''' ,'''residual_layer1'''							)
   if "resConfUnit2" in name:
      __lowerCamelCase													=    name.replace('''resConfUnit2''' ,'''residual_layer2'''							)
   if "conv1" in name:
      __lowerCamelCase													=    name.replace('''conv1''' ,'''convolution1'''							)
   if "conv2" in name:
      __lowerCamelCase													=    name.replace('''conv2''' ,'''convolution2'''							)
   # readout blocks
   if "pretrained.act_postprocess1.0.project.0" in name:
      __lowerCamelCase													=    name.replace('''pretrained.act_postprocess1.0.project.0''' ,'''neck.reassemble_stage.readout_projects.0.0'''							)
   if "pretrained.act_postprocess2.0.project.0" in name:
      __lowerCamelCase													=    name.replace('''pretrained.act_postprocess2.0.project.0''' ,'''neck.reassemble_stage.readout_projects.1.0'''							)
   if "pretrained.act_postprocess3.0.project.0" in name:
      __lowerCamelCase													=    name.replace('''pretrained.act_postprocess3.0.project.0''' ,'''neck.reassemble_stage.readout_projects.2.0'''							)
   if "pretrained.act_postprocess4.0.project.0" in name:
      __lowerCamelCase													=    name.replace('''pretrained.act_postprocess4.0.project.0''' ,'''neck.reassemble_stage.readout_projects.3.0'''							)

   # resize blocks
   if "pretrained.act_postprocess1.3" in name:
      __lowerCamelCase													=    name.replace('''pretrained.act_postprocess1.3''' ,'''neck.reassemble_stage.layers.0.projection'''							)
   if "pretrained.act_postprocess1.4" in name:
      __lowerCamelCase													=    name.replace('''pretrained.act_postprocess1.4''' ,'''neck.reassemble_stage.layers.0.resize'''							)
   if "pretrained.act_postprocess2.3" in name:
      __lowerCamelCase													=    name.replace('''pretrained.act_postprocess2.3''' ,'''neck.reassemble_stage.layers.1.projection'''							)
   if "pretrained.act_postprocess2.4" in name:
      __lowerCamelCase													=    name.replace('''pretrained.act_postprocess2.4''' ,'''neck.reassemble_stage.layers.1.resize'''							)
   if "pretrained.act_postprocess3.3" in name:
      __lowerCamelCase													=    name.replace('''pretrained.act_postprocess3.3''' ,'''neck.reassemble_stage.layers.2.projection'''							)
   if "pretrained.act_postprocess4.3" in name:
      __lowerCamelCase													=    name.replace('''pretrained.act_postprocess4.3''' ,'''neck.reassemble_stage.layers.3.projection'''							)
   if "pretrained.act_postprocess4.4" in name:
      __lowerCamelCase													=    name.replace('''pretrained.act_postprocess4.4''' ,'''neck.reassemble_stage.layers.3.resize'''							)
   if "pretrained" in name:
      __lowerCamelCase													=    name.replace('''pretrained''' ,'''dpt'''							)
   if "bn" in name:
      __lowerCamelCase													=    name.replace('''bn''' ,'''batch_norm'''							)
   if "head" in name:
      __lowerCamelCase													=    name.replace('''head''' ,'''head.head'''							)
   if "encoder.norm" in name:
      __lowerCamelCase													=    name.replace('''encoder.norm''' ,'''layernorm'''							)
   if "auxlayer" in name:
      __lowerCamelCase													=    name.replace('''auxlayer''' ,'''auxiliary_head.head'''							)
   if "backbone" in name:
      __lowerCamelCase													=    name.replace('''backbone''' ,'''backbone.bit.encoder'''							)

   if ".." in name:
      __lowerCamelCase													=    name.replace('''..''' ,'''.'''							)

   if "stem.conv" in name:
      __lowerCamelCase													=    name.replace('''stem.conv''' ,'''bit.embedder.convolution'''							)
   if "blocks" in name:
      __lowerCamelCase													=    name.replace('''blocks''' ,'''layers'''							)
   if "convolution" in name and "backbone" in name:
      __lowerCamelCase													=    name.replace('''convolution''' ,'''conv'''							)
   if "layer" in name and "backbone" in name:
      __lowerCamelCase													=    name.replace('''layer''' ,'''layers'''							)
   if "backbone.bit.encoder.bit" in name:
      __lowerCamelCase													=    name.replace('''backbone.bit.encoder.bit''' ,'''backbone.bit'''							)
   if "embedder.conv" in name:
      __lowerCamelCase													=    name.replace('''embedder.conv''' ,'''embedder.convolution'''							)
   if "backbone.bit.encoder.stem.norm" in name:
      __lowerCamelCase													=    name.replace('''backbone.bit.encoder.stem.norm''' ,'''backbone.bit.embedder.norm'''							)
   return name



def 		a__			(		_UpperCamelCase			: List[Any] ,_UpperCamelCase			: Dict							):




   for i in range(config.num_hidden_layers							):
      # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
      __lowerCamelCase													=    state_dict.pop(F"""dpt.encoder.layer.{i}.attn.qkv.weight"""							)
      __lowerCamelCase													=    state_dict.pop(F"""dpt.encoder.layer.{i}.attn.qkv.bias"""							)
      # next, add query, keys and values (in that order) to the state dict
      __lowerCamelCase													=    in_proj_weight[: config.hidden_size, :]
      __lowerCamelCase													=    in_proj_bias[: config.hidden_size]
      __lowerCamelCase													=    in_proj_weight[
          config.hidden_size : config.hidden_size * 2, :
      ]
      __lowerCamelCase													=    in_proj_bias[
          config.hidden_size : config.hidden_size * 2
      ]
      __lowerCamelCase													=    in_proj_weight[
          -config.hidden_size :, :
      ]
      __lowerCamelCase													=    in_proj_bias[-config.hidden_size :]



def 		a__			(		):
   __lowerCamelCase													=    "http://images.cocodataset.org/val2017/000000039769.jpg"
   __lowerCamelCase													=    Image.open(requests.get(_A ,stream=_A							).raw							)
   return im



@torch.no_grad()
def 		a__			(		_UpperCamelCase			: List[str] ,_UpperCamelCase			: str ,_UpperCamelCase			: List[str] ,_UpperCamelCase			: Optional[Any] ,_UpperCamelCase			: List[str]							):
   __lowerCamelCase													=    get_dpt_config(_A							)
   # load original state_dict from URL
   # state_dict = torch.hub.load_state_dict_from_url(checkpoint_url, map_location="cpu")
   __lowerCamelCase													=    torch.load(_A ,map_location='''cpu'''							)
   # remove certain keys
   remove_ignore_keys_(_A							)
   # rename keys
   for key in state_dict.copy().keys():
      __lowerCamelCase													=    state_dict.pop(_A							)
      __lowerCamelCase													=    val
   # read in qkv matrices
   read_in_q_k_v(_A ,_A							)

   # load HuggingFace model
   __lowerCamelCase													=    DPTForSemanticSegmentation(_A							) if "ade" in checkpoint_url else DPTForDepthEstimation(_A							)
   model.load_state_dict(_A							)
   model.eval()

   # Check outputs on an image
   __lowerCamelCase													=    4_80 if "ade" in checkpoint_url else 3_84
   __lowerCamelCase													=    DPTImageProcessor(size=_A							)

   __lowerCamelCase													=    prepare_img()
   __lowerCamelCase													=    image_processor(_A ,return_tensors='''pt'''							)

   # forward pass
   __lowerCamelCase													=    model(**_A							).logits if "ade" in checkpoint_url else model(**_A							).predicted_depth

   if show_prediction:
      __lowerCamelCase													=    (
          torch.nn.functional.interpolate(
              outputs.unsqueeze(1							) ,size=(image.size[1], image.size[0]) ,mode='''bicubic''' ,align_corners=_A ,)
          .squeeze()
          .cpu()
          .numpy()
      )

      Image.fromarray((prediction / prediction.max()) * 2_55							).show()

   if pytorch_dump_folder_path is not None:
      Path(_A							).mkdir(exist_ok=_A							)
      print(F"""Saving model to {pytorch_dump_folder_path}"""							)
      model.save_pretrained(_A							)
      print(F"""Saving image processor to {pytorch_dump_folder_path}"""							)
      image_processor.save_pretrained(_A							)

   if push_to_hub:
      model.push_to_hub('''ybelkada/dpt-hybrid-midas'''							)
      image_processor.push_to_hub('''ybelkada/dpt-hybrid-midas'''							)


if __name__ == "__main__":
  a_			=					argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      """--checkpoint_url""",
      default="""https://github.com/intel-isl/DPT/releases/download/1_0/dpt_large-midas-2f21e586.pt""",
      type=str,
      help="""URL of the original DPT checkpoint you'd like to convert.""",
  )
  parser.add_argument(
      """--pytorch_dump_folder_path""",
      default=None,
      type=str,
      required=False,
      help="""Path to the output PyTorch model directory.""",
  )
  parser.add_argument(
      """--push_to_hub""",
      action="""store_true""",
  )
  parser.add_argument(
      """--model_name""",
      default="""dpt-large""",
      type=str,
      help="""Name of the model, in case you're pushing to the hub.""",
  )
  parser.add_argument(
      """--show_prediction""",
      action="""store_true""",
  )

  a_			=					parser.parse_args()
  convert_dpt_checkpoint(
      args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name, args.show_prediction
  )











import unittest

from transformers.models.xlm_prophetnet.tokenization_xlm_prophetnet import SPIECE_UNDERLINE, XLMProphetNetTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


a_			=					get_tests_dir("""fixtures/test_sentencepiece.model""")



@require_sentencepiece
class  __lowerCAmelCase     (	lowerCAmelCase__  ,	unittest.TestCase   ):
 lowerCAmelCase__       					=  XLMProphetNetTokenizer
 lowerCAmelCase__       					=  False
 lowerCAmelCase__       					=  True




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    super().setUp()

    # We have a SentencePiece fixture for testing
    __lowerCamelCase													=    XLMProphetNetTokenizer(__UpperCAmelCase	,				keep_accents=__UpperCAmelCase				)
    tokenizer.save_pretrained(self.tmpdirname				)




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    '''[PAD]'''
    __lowerCamelCase													=    0

    self.assertEqual(self.get_tokenizer()._convert_token_to_id(__UpperCAmelCase				)	,				__UpperCAmelCase				)
    self.assertEqual(self.get_tokenizer()._convert_id_to_token(__UpperCAmelCase				)	,				__UpperCAmelCase				)




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    list(self.get_tokenizer().get_vocab().keys()				)

    self.assertEqual(vocab_keys[0]	,				'''[PAD]'''				)
    self.assertEqual(vocab_keys[1]	,				'''[CLS]'''				)
    self.assertEqual(vocab_keys[-1]	,				'''j'''				)
    self.assertEqual(len(__UpperCAmelCase				)	,				1012				)




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    self.assertEqual(self.get_tokenizer().vocab_size	,				1012				)




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    XLMProphetNetTokenizer(__UpperCAmelCase	,				keep_accents=__UpperCAmelCase				)

    __lowerCamelCase													=    tokenizer.tokenize('''This is a test'''				)
    self.assertListEqual(__UpperCAmelCase	,				['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']				)

    self.assertListEqual(
        tokenizer.convert_tokens_to_ids(__UpperCAmelCase				)	,				[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]	,				)

    __lowerCamelCase													=    tokenizer.tokenize('''I was born in 92000, and this is falsé.'''				)
    self.assertListEqual(
        __UpperCAmelCase	,				[
            SPIECE_UNDERLINE + '''I''',
            SPIECE_UNDERLINE + '''was''',
            SPIECE_UNDERLINE + '''b''',
            '''or''',
            '''n''',
            SPIECE_UNDERLINE + '''in''',
            SPIECE_UNDERLINE + '''''',
            '''9''',
            '''2''',
            '''0''',
            '''0''',
            '''0''',
            ''',''',
            SPIECE_UNDERLINE + '''and''',
            SPIECE_UNDERLINE + '''this''',
            SPIECE_UNDERLINE + '''is''',
            SPIECE_UNDERLINE + '''f''',
            '''al''',
            '''s''',
            '''é''',
            '''.''',
        ]	,				)
    __lowerCamelCase													=    tokenizer.convert_tokens_to_ids(__UpperCAmelCase				)
    self.assertListEqual(
        __UpperCAmelCase	,				[
            value + tokenizer.fairseq_offset
            for value in [8, 21, 84, 55, 24, 19, 7, -9, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, -9, 4]
        ]	,				)

    __lowerCamelCase													=    tokenizer.convert_ids_to_tokens(__UpperCAmelCase				)
    self.assertListEqual(
        __UpperCAmelCase	,				[
            SPIECE_UNDERLINE + '''I''',
            SPIECE_UNDERLINE + '''was''',
            SPIECE_UNDERLINE + '''b''',
            '''or''',
            '''n''',
            SPIECE_UNDERLINE + '''in''',
            SPIECE_UNDERLINE + '''''',
            '''[UNK]''',
            '''2''',
            '''0''',
            '''0''',
            '''0''',
            ''',''',
            SPIECE_UNDERLINE + '''and''',
            SPIECE_UNDERLINE + '''this''',
            SPIECE_UNDERLINE + '''is''',
            SPIECE_UNDERLINE + '''f''',
            '''al''',
            '''s''',
            '''[UNK]''',
            '''.''',
        ]	,				)




 @cached_property
 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    return XLMProphetNetTokenizer.from_pretrained('''microsoft/xprophetnet-large-wiki100-cased'''				)




 @slow
 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    '''Hello World!'''
    __lowerCamelCase													=    [35389, 6672, 49, 2]
    self.assertListEqual(__UpperCAmelCase	,				self.big_tokenizer.encode(__UpperCAmelCase				)				)




 @slow
 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    # fmt: off
    __lowerCamelCase													=    {'''input_ids''': [[11073, 82783, 18, 26, 82783, 549, 51540, 248, 17209, 1301, 217, 20, 215186, 1325, 147, 17209, 1301, 217, 20, 56370, 53, 122020, 20, 16477, 27, 87355, 4548, 20, 4728, 78392, 17, 159969, 18, 26, 24491, 629, 15, 538, 22704, 5439, 15, 2788, 24491, 9885, 15, 43534, 605, 15, 814, 18403, 33200, 29, 15, 43534, 24458, 12410, 111, 24966, 83669, 9637, 144068, 26, 850, 22346, 27, 147, 24966, 83669, 83490, 26, 39113, 735, 27, 689, 656, 2800, 1339, 4600, 53, 122020, 115785, 34, 816, 1339, 46887, 18, 147, 53905, 1951, 42238, 41170, 17732, 834, 436, 15, 27523, 98733, 217, 147, 5542, 4981, 930, 17347, 16, 2], [20091, 629, 94, 82786, 58, 490, 20, 1528, 84, 53905, 344, 80592, 110128, 18822, 5267, 1306, 62, 152537, 308, 7997, 401, 124427, 549, 35442, 225, 109, 15055, 25748, 147, 7119, 43712, 34, 767, 135366, 18, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [592, 63784, 119466, 17, 147808, 88214, 18, 656, 81, 32, 3296, 10280, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
    # fmt: on

    self.tokenizer_integration_test_util(
        expected_encoding=__UpperCAmelCase	,				model_name='''microsoft/xprophetnet-large-wiki100-cased'''	,				revision='''1acad1643ddd54a44df6a1b797ada8373685d90e'''	,				)






