'''simple docstring'''






import inspect
import unittest

from transformers import DPTConfig
from transformers.file_utils import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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


if is_torch_available():
    import torch
    from torch import nn

    from transformers import MODEL_MAPPING, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTModel
    from transformers.models.dpt.modeling_dpt import DPT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import DPTImageProcessor




class    a :



  """simple docstring"""







  def __init__(							self   ,    snake_case_   ,    snake_case_=2   ,    snake_case_=32   ,    snake_case_=16   ,    snake_case_=3   ,    snake_case_=True   ,    snake_case_=True   ,    snake_case_=32   ,    snake_case_=4   ,    snake_case_=[0, 1, 2, 3]   ,    snake_case_=4   ,    snake_case_=37   ,    snake_case_="gelu"   ,    snake_case_=0.1   ,    snake_case_=0.1   ,    snake_case_=0.0_2   ,    snake_case_=3   ,    snake_case_=[1, 384, 24, 24]   ,    snake_case_=True   ,    snake_case_=None   ,    ):

    '''simple docstring'''







    __UpperCAmelCase:					Any		= parent
    __UpperCAmelCase:					str		= batch_size
    __UpperCAmelCase:					Union[str, Any]		= image_size
    __UpperCAmelCase:					Tuple		= patch_size
    __UpperCAmelCase:					Dict		= num_channels
    __UpperCAmelCase:					int		= is_training
    __UpperCAmelCase:					Optional[int]		= use_labels
    __UpperCAmelCase:					Optional[int]		= hidden_size
    __UpperCAmelCase:					List[str]		= num_hidden_layers
    __UpperCAmelCase:					Optional[int]		= backbone_out_indices
    __UpperCAmelCase:					Union[str, Any]		= num_attention_heads
    __UpperCAmelCase:					Optional[int]		= intermediate_size
    __UpperCAmelCase:					int		= hidden_act
    __UpperCAmelCase:					Tuple		= hidden_dropout_prob
    __UpperCAmelCase:					Optional[Any]		= attention_probs_dropout_prob
    __UpperCAmelCase:					str		= initializer_range
    __UpperCAmelCase:					Any		= num_labels
    __UpperCAmelCase:					Optional[Any]		= backbone_featmap_shape
    __UpperCAmelCase:					str		= scope
    __UpperCAmelCase:					Optional[Any]		= is_hybrid
    # sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
    __UpperCAmelCase:					Tuple		= (image_size // patch_size) ** 2
    __UpperCAmelCase:					Any		= num_patches + 1







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Optional[int]		= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

    __UpperCAmelCase:					int		= None
    if self.use_labels:
      __UpperCAmelCase:					Union[str, Any]		= ids_tensor([self.batch_size, self.image_size, self.image_size]   ,    self.num_labels					)

    __UpperCAmelCase:					List[str]		= self.get_config()

    return config, pixel_values, labels







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Tuple		= {
        """global_padding""": """same""",
        """layer_type""": """bottleneck""",
        """depths""": [3, 4, 9],
        """out_features""": ["""stage1""", """stage2""", """stage3"""],
        """embedding_dynamic_padding""": True,
        """hidden_sizes""": [96, 192, 384, 768],
        """num_groups""": 2,
    }

    return DPTConfig(
        image_size=self.image_size   ,    patch_size=self.patch_size   ,    num_channels=self.num_channels   ,    hidden_size=self.hidden_size   ,    num_hidden_layers=self.num_hidden_layers   ,    backbone_out_indices=self.backbone_out_indices   ,    num_attention_heads=self.num_attention_heads   ,    intermediate_size=self.intermediate_size   ,    hidden_act=self.hidden_act   ,    hidden_dropout_prob=self.hidden_dropout_prob   ,    attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,    is_decoder=snake_case_   ,    initializer_range=self.initializer_range   ,    is_hybrid=self.is_hybrid   ,    backbone_config=snake_case_   ,    backbone_featmap_shape=self.backbone_featmap_shape   ,    )







  def    lowercase_  (							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Optional[int]		= DPTModel(config=snake_case_					)
    model.to(snake_case_					)
    model.eval()
    __UpperCAmelCase:					List[Any]		= model(snake_case_					)
    self.parent.assertEqual(result.last_hidden_state.shape   ,    (self.batch_size, self.seq_length, self.hidden_size)					)







  def    lowercase_  (							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Dict		= self.num_labels
    __UpperCAmelCase:					Optional[Any]		= DPTForDepthEstimation(snake_case_					)
    model.to(snake_case_					)
    model.eval()
    __UpperCAmelCase:					List[Any]		= model(snake_case_					)
    self.parent.assertEqual(result.predicted_depth.shape   ,    (self.batch_size, self.image_size, self.image_size)					)







  def    lowercase_  (							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					List[str]		= self.num_labels
    __UpperCAmelCase:					Tuple		= DPTForSemanticSegmentation(snake_case_					)
    model.to(snake_case_					)
    model.eval()
    __UpperCAmelCase:					Optional[Any]		= model(snake_case_   ,    labels=snake_case_					)
    self.parent.assertEqual(
        result.logits.shape   ,    (self.batch_size, self.num_labels, self.image_size, self.image_size)					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					List[Any]		= self.prepare_config_and_inputs()
    __UpperCAmelCase, __UpperCAmelCase, __UpperCAmelCase:					List[Any]		= config_and_inputs
    __UpperCAmelCase:					Tuple		= {"""pixel_values""": pixel_values}
    return config, inputs_dict




@require_torch
class    a (       __lowerCAmelCase						,  __lowerCAmelCase						,  unittest.TestCase				):



  """simple docstring"""
  __lowerCAmelCase				      =					(DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
  __lowerCAmelCase				      =					(
      {
          """depth-estimation""": DPTForDepthEstimation,
          """feature-extraction""": DPTModel,
          """image-segmentation""": DPTForSemanticSegmentation,
      }
      if is_torch_available()
      else {}
  )

  __lowerCAmelCase				      =					False
  __lowerCAmelCase				      =					False
  __lowerCAmelCase				      =					False







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					str		= DPTModelTester(self					)
    __UpperCAmelCase:					List[Any]		= ConfigTester(self   ,    config_class=snake_case_   ,    has_text_modality=snake_case_   ,    hidden_size=37					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    self.config_tester.run_common_tests()







  @unittest.skip(reason="""DPT does not use inputs_embeds"""					)
  def    lowercase_  (							self					):

    '''simple docstring'''







    pass







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase, __UpperCAmelCase:					Tuple		= self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
      __UpperCAmelCase:					Union[str, Any]		= model_class(snake_case_					)
      self.assertIsInstance(model.get_input_embeddings()   ,    (nn.Module)					)
      __UpperCAmelCase:					Any		= model.get_output_embeddings()
      self.assertTrue(x is None or isinstance(snake_case_   ,    nn.Linear					)					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase, __UpperCAmelCase:					Tuple		= self.model_tester.prepare_config_and_inputs_for_common()

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

      __UpperCAmelCase:					Dict		= ["""pixel_values"""]
      self.assertListEqual(arg_names[:1]   ,    snake_case_					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					List[str]		= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*snake_case_					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Tuple		= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_depth_estimation(*snake_case_					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Optional[int]		= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_semantic_segmentation(*snake_case_					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    for model_class in self.all_model_classes:
      if model_class.__name__ == "DPTForDepthEstimation":
        continue

      __UpperCAmelCase, __UpperCAmelCase:					List[str]		= self.model_tester.prepare_config_and_inputs_for_common()
      __UpperCAmelCase:					Union[str, Any]		= True

      if model_class in get_values(snake_case_					):
        continue

      __UpperCAmelCase:					Dict		= model_class(snake_case_					)
      model.to(snake_case_					)
      model.train()
      __UpperCAmelCase:					Any		= self._prepare_for_class(snake_case_   ,    snake_case_   ,    return_labels=snake_case_					)
      __UpperCAmelCase:					Optional[Any]		= model(**snake_case_					).loss
      loss.backward()







  def    lowercase_  (							self					):

    '''simple docstring'''







    for model_class in self.all_model_classes:
      if model_class.__name__ == "DPTForDepthEstimation":
        continue

      __UpperCAmelCase, __UpperCAmelCase:					Optional[int]		= self.model_tester.prepare_config_and_inputs_for_common()
      __UpperCAmelCase:					int		= False
      __UpperCAmelCase:					Dict		= True

      if model_class in get_values(snake_case_					) or not model_class.supports_gradient_checkpointing:
        continue
      __UpperCAmelCase:					str		= model_class(snake_case_					)
      model.to(snake_case_					)
      model.gradient_checkpointing_enable()
      model.train()
      __UpperCAmelCase:					Optional[Any]		= self._prepare_for_class(snake_case_   ,    snake_case_   ,    return_labels=snake_case_					)
      __UpperCAmelCase:					Union[str, Any]		= model(**snake_case_					).loss
      loss.backward()







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase, __UpperCAmelCase:					Optional[int]		= self.model_tester.prepare_config_and_inputs_for_common()

    __UpperCAmelCase:					int		= _config_zero_init(snake_case_					)
    for model_class in self.all_model_classes:
      __UpperCAmelCase:					Any		= model_class(config=snake_case_					)
      # Skip the check for the backbone
      __UpperCAmelCase:					Optional[int]		= []
      for name, module in model.named_modules():
        if module.__class__.__name__ == "DPTViTHybridEmbeddings":
          __UpperCAmelCase:					Union[str, Any]		= [F'''{name}.{key}''' for key in module.state_dict().keys()]
          break

      for name, param in model.named_parameters():
        if param.requires_grad:
          if name in backbone_params:
            continue
          self.assertIn(
              ((param.data.mean() * 1e9).round() / 1e9).item()   ,    [0.0, 1.0]   ,    msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''   ,    )







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

    '''simple docstring'''







    pass







  @slow
  def    lowercase_  (							self					):

    '''simple docstring'''







    for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]:
      __UpperCAmelCase:					Union[str, Any]		= DPTModel.from_pretrained(snake_case_					)
      self.assertIsNotNone(snake_case_					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase, __UpperCAmelCase:					Any		= self.model_tester.prepare_config_and_inputs_for_common()
    __UpperCAmelCase:					Tuple		= """add"""
    with self.assertRaises(snake_case_					):
      __UpperCAmelCase:					str		= DPTForDepthEstimation(snake_case_					)






def  UpperCamelCase__					(					)							->	Any:
  __UpperCAmelCase:					Optional[Any]		= Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""     )
  return image







@require_torch
@require_vision
@slow
class    a (       unittest.TestCase				):



  """simple docstring"""







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					str		= DPTImageProcessor.from_pretrained("""Intel/dpt-hybrid-midas"""					)
    __UpperCAmelCase:					Union[str, Any]		= DPTForDepthEstimation.from_pretrained("""Intel/dpt-hybrid-midas"""					).to(snake_case_					)

    __UpperCAmelCase:					int		= prepare_img()
    __UpperCAmelCase:					int		= image_processor(images=snake_case_   ,    return_tensors="""pt"""					).to(snake_case_					)

    # forward pass
    with torch.no_grad():
      __UpperCAmelCase:					Tuple		= model(**snake_case_					)
      __UpperCAmelCase:					Tuple		= outputs.predicted_depth

    # verify the predicted depth
    __UpperCAmelCase:					Dict		= torch.Size((1, 384, 384)					)
    self.assertEqual(predicted_depth.shape   ,    snake_case_					)

    __UpperCAmelCase:					int		= torch.tensor(
        [[[5.6_4_3_7, 5.6_1_4_6, 5.6_5_1_1], [5.4_3_7_1, 5.5_6_4_9, 5.5_9_5_8], [5.5_2_1_5, 5.5_1_8_4, 5.5_2_9_3]]]					).to(snake_case_					)

    self.assertTrue(torch.allclose(outputs.predicted_depth[:3, :3, :3] / 100   ,    snake_case_   ,    atol=1e-4					)					)
'''simple docstring'''






import unittest

from transformers import JukeboxTokenizer
from transformers.testing_utils import require_torch




class    a (       unittest.TestCase				):



  """simple docstring"""
  __lowerCAmelCase				      =					JukeboxTokenizer
  __lowerCAmelCase				      =					{
      """artist""": """Zac Brown Band""",
      """genres""": """Country""",
      """lyrics""": """I met a traveller from an antique land,
        Who said \"Two vast and trunkless legs of stone
        Stand in the desert. . . . Near them, on the sand,
        Half sunk a shattered visage lies, whose frown,
        And wrinkled lip, and sneer of cold command,
        Tell that its sculptor well those passions read
        Which yet survive, stamped on these lifeless things,
        The hand that mocked them, and the heart that fed;
        And on the pedestal, these words appear:
        My name is Ozymandias, King of Kings;
        Look on my Works, ye Mighty, and despair!
        Nothing beside remains. Round the decay
        Of that colossal Wreck, boundless and bare
        The lone and level sands stretch far away
        """,
  }







  @require_torch
  def    lowercase_  (							self					):

    '''simple docstring'''







    import torch

    __UpperCAmelCase:					Dict		= JukeboxTokenizer.from_pretrained("""openai/jukebox-1b-lyrics"""					)
    __UpperCAmelCase:					List[str]		= tokenizer(**self.metas					)["""input_ids"""]
    # fmt: off
    __UpperCAmelCase:					int		= [
        torch.tensor([[
            0, 0, 0, 7169, 507, 9, 76, 39, 31, 46, 76, 27,
            76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32,
            44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43,
            47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76,
            76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35,
            30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76,
            27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45,
            45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46,
            41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76,
            19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31,
            76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63,
            76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39,
            64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40,
            30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8,
            27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45,
            34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45,
            27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34,
            41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76,
            76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49,
            44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64,
            76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41,
            32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27,
            40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76,
            20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46,
            45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49,
            31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27,
            45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78,
            76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29,
            34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48,
            31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41,
            40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31,
            38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64,
            78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31,
            76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39,
            41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76,
            27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44,
            46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78,
            76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76,
            41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45,
            46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49,
            41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65,
            78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76,
            40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39,
            27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33,
            76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76,
            76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76,
            41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64,
            76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76,
            27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67,
            78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46,
            34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76,
            44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47,
            40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51,
            78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76,
            46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27,
            38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47,
            40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28,
            27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76,
            20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30,
            76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45,
            76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44,
            76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76,
            76, 76]]					),
        torch.tensor([[0, 0, 0, 1069, 11]]					),
        torch.tensor([[0, 0, 0, 1069, 11]]					),
    ]
    # fmt: on
    self.assertTrue(torch.allclose(tokens[0]   ,    EXPECTED_OUTPUT[0]					)					)
    self.assertTrue(torch.allclose(tokens[1]   ,    EXPECTED_OUTPUT[1]					)					)
    self.assertTrue(torch.allclose(tokens[2]   ,    EXPECTED_OUTPUT[2]					)					)







  @require_torch
  def    lowercase_  (							self					):

    '''simple docstring'''







    import torch

    __UpperCAmelCase:					Any		= JukeboxTokenizer.from_pretrained("""openai/jukebox-5b-lyrics"""					)
    __UpperCAmelCase:					Tuple		= tokenizer(**self.metas					)["""input_ids"""]
    # fmt: off
    __UpperCAmelCase:					int		= [
        torch.tensor([[
            0, 0, 0, 1069, 11, -1, -1, -1, -1, 9, 77, 39,
            31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38,
            31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27,
            40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64,
            79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41,
            77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48,
            27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40,
            37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41,
            32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77,
            77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40,
            77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63,
            77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77,
            46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31,
            77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77,
            77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37,
            77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30,
            77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45,
            64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49,
            40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1,
            40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77,
            38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31,
            31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29,
            41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77,
            77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27,
            46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46,
            41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45,
            31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44,
            31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77,
            23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47,
            44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42,
            31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77,
            38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35,
            40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77,
            77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34,
            27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34,
            31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77,
            34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32,
            31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77,
            1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42,
            31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31,
            45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42,
            31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77,
            77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77,
            15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77,
            11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33,
            45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12,
            41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41,
            44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34,
            46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42,
            27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77,
            77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45,
            35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63,
            77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30,
            31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77,
            77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38,
            41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64,
            77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27,
            40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77,
            77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31,
            77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45,
            27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34,
            77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77,
            77, 77, 77, 77, 77, 77]]					),
        torch.tensor([[0, 0, 0, 1069, 11, -1, -1, -1, -1]]					),
        torch.tensor([[0, 0, 0, 1069, 11, -1, -1, -1, -1]]					),
    ]
    # fmt: on
    self.assertTrue(torch.allclose(tokens[0]   ,    EXPECTED_OUTPUT[0]					)					)
    self.assertTrue(torch.allclose(tokens[1]   ,    EXPECTED_OUTPUT[1]					)					)
    self.assertTrue(torch.allclose(tokens[2]   ,    EXPECTED_OUTPUT[2]					)					)