


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()
_SCREAMING_SNAKE_CASE     :					List[Any]      =       logging.get_logger(__name__)
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     snake_case											=							DPTConfig()

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

     if "ade" in checkpoint_url:
          snake_case											=							True

          snake_case											=							1_50
          snake_case											=							'''huggingface/label-files'''
          snake_case											=							'''ade20k-id2label.json'''
          snake_case											=							json.load(open(cached_download(hf_hub_url(UpperCamelCase_				,UpperCamelCase_				,repo_type='''dataset'''							)							)				,'''r'''							)							)
          snake_case											=							{int(UpperCamelCase_							): v for k, v in idalabel.items()}
          snake_case											=							idalabel
          snake_case											=							{v: k for k, v in idalabel.items()}
          snake_case											=							[1, 1_50, 4_80, 4_80]

     return config, expected_shape
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     snake_case											=							['''pretrained.model.head.weight''', '''pretrained.model.head.bias''']
     for k in ignore_keys:
          state_dict.pop(UpperCamelCase_				,UpperCamelCase_							)
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     if (
         "pretrained.model" in name
         and "cls_token" not in name
         and "pos_embed" not in name
         and "patch_embed" not in name
     ):
          snake_case											=							name.replace('''pretrained.model'''				,'''dpt.encoder'''							)
     if "pretrained.model" in name:
          snake_case											=							name.replace('''pretrained.model'''				,'''dpt.embeddings'''							)
     if "patch_embed" in name:
          snake_case											=							name.replace('''patch_embed'''				,'''patch_embeddings'''							)
     if "pos_embed" in name:
          snake_case											=							name.replace('''pos_embed'''				,'''position_embeddings'''							)
     if "attn.proj" in name:
          snake_case											=							name.replace('''attn.proj'''				,'''attention.output.dense'''							)
     if "proj" in name and "project" not in name:
          snake_case											=							name.replace('''proj'''				,'''projection'''							)
     if "blocks" in name:
          snake_case											=							name.replace('''blocks'''				,'''layer'''							)
     if "mlp.fc1" in name:
          snake_case											=							name.replace('''mlp.fc1'''				,'''intermediate.dense'''							)
     if "mlp.fc2" in name:
          snake_case											=							name.replace('''mlp.fc2'''				,'''output.dense'''							)
     if "norm1" in name:
          snake_case											=							name.replace('''norm1'''				,'''layernorm_before'''							)
     if "norm2" in name:
          snake_case											=							name.replace('''norm2'''				,'''layernorm_after'''							)
     if "scratch.output_conv" in name:
          snake_case											=							name.replace('''scratch.output_conv'''				,'''head'''							)
     if "scratch" in name:
          snake_case											=							name.replace('''scratch'''				,'''neck'''							)
     if "layer1_rn" in name:
          snake_case											=							name.replace('''layer1_rn'''				,'''convs.0'''							)
     if "layer2_rn" in name:
          snake_case											=							name.replace('''layer2_rn'''				,'''convs.1'''							)
     if "layer3_rn" in name:
          snake_case											=							name.replace('''layer3_rn'''				,'''convs.2'''							)
     if "layer4_rn" in name:
          snake_case											=							name.replace('''layer4_rn'''				,'''convs.3'''							)
     if "refinenet" in name:
          snake_case											=							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
          snake_case											=							name.replace(F'''refinenet{layer_idx}'''				,F'''fusion_stage.layers.{abs(layer_idx-4							)}'''							)
     if "out_conv" in name:
          snake_case											=							name.replace('''out_conv'''				,'''projection'''							)
     if "resConfUnit1" in name:
          snake_case											=							name.replace('''resConfUnit1'''				,'''residual_layer1'''							)
     if "resConfUnit2" in name:
          snake_case											=							name.replace('''resConfUnit2'''				,'''residual_layer2'''							)
     if "conv1" in name:
          snake_case											=							name.replace('''conv1'''				,'''convolution1'''							)
     if "conv2" in name:
          snake_case											=							name.replace('''conv2'''				,'''convolution2'''							)
     # readout blocks
     if "pretrained.act_postprocess1.0.project.0" in name:
          snake_case											=							name.replace('''pretrained.act_postprocess1.0.project.0'''				,'''neck.reassemble_stage.readout_projects.0.0'''							)
     if "pretrained.act_postprocess2.0.project.0" in name:
          snake_case											=							name.replace('''pretrained.act_postprocess2.0.project.0'''				,'''neck.reassemble_stage.readout_projects.1.0'''							)
     if "pretrained.act_postprocess3.0.project.0" in name:
          snake_case											=							name.replace('''pretrained.act_postprocess3.0.project.0'''				,'''neck.reassemble_stage.readout_projects.2.0'''							)
     if "pretrained.act_postprocess4.0.project.0" in name:
          snake_case											=							name.replace('''pretrained.act_postprocess4.0.project.0'''				,'''neck.reassemble_stage.readout_projects.3.0'''							)
     # resize blocks
     if "pretrained.act_postprocess1.3" in name:
          snake_case											=							name.replace('''pretrained.act_postprocess1.3'''				,'''neck.reassemble_stage.layers.0.projection'''							)
     if "pretrained.act_postprocess1.4" in name:
          snake_case											=							name.replace('''pretrained.act_postprocess1.4'''				,'''neck.reassemble_stage.layers.0.resize'''							)
     if "pretrained.act_postprocess2.3" in name:
          snake_case											=							name.replace('''pretrained.act_postprocess2.3'''				,'''neck.reassemble_stage.layers.1.projection'''							)
     if "pretrained.act_postprocess2.4" in name:
          snake_case											=							name.replace('''pretrained.act_postprocess2.4'''				,'''neck.reassemble_stage.layers.1.resize'''							)
     if "pretrained.act_postprocess3.3" in name:
          snake_case											=							name.replace('''pretrained.act_postprocess3.3'''				,'''neck.reassemble_stage.layers.2.projection'''							)
     if "pretrained.act_postprocess4.3" in name:
          snake_case											=							name.replace('''pretrained.act_postprocess4.3'''				,'''neck.reassemble_stage.layers.3.projection'''							)
     if "pretrained.act_postprocess4.4" in name:
          snake_case											=							name.replace('''pretrained.act_postprocess4.4'''				,'''neck.reassemble_stage.layers.3.resize'''							)
     if "pretrained" in name:
          snake_case											=							name.replace('''pretrained'''				,'''dpt'''							)
     if "bn" in name:
          snake_case											=							name.replace('''bn'''				,'''batch_norm'''							)
     if "head" in name:
          snake_case											=							name.replace('''head'''				,'''head.head'''							)
     if "encoder.norm" in name:
          snake_case											=							name.replace('''encoder.norm'''				,'''layernorm'''							)
     if "auxlayer" in name:
          snake_case											=							name.replace('''auxlayer'''				,'''auxiliary_head.head'''							)

     return name
def      UpperCAmelCase__		(UpperCamelCase_				,UpperCamelCase_							):



     """simple docstring"""






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



     """simple docstring"""






     snake_case											=							'''http://images.cocodataset.org/val2017/000000039769.jpg'''
     snake_case											=							Image.open(requests.get(UpperCamelCase_				,stream=UpperCamelCase_							).raw							)
     return im
@torch.no_grad()
def      UpperCAmelCase__		(UpperCamelCase_				,UpperCamelCase_				,UpperCamelCase_				,UpperCamelCase_							):



     """simple docstring"""






     snake_case					,    snake_case											=							get_dpt_config(UpperCamelCase_							)
     # load original state_dict from URL
     snake_case											=							torch.hub.load_state_dict_from_url(UpperCamelCase_				,map_location='''cpu'''							)
     # remove certain keys
     remove_ignore_keys_(UpperCamelCase_							)
     # rename keys
     for key in state_dict.copy().keys():
          snake_case											=							state_dict.pop(UpperCamelCase_							)
          snake_case											=							val
     # read in qkv matrices
     read_in_q_k_v(UpperCamelCase_				,UpperCamelCase_							)

     # load HuggingFace model
     snake_case											=							DPTForSemanticSegmentation(UpperCamelCase_							) if '''ade''' in checkpoint_url else DPTForDepthEstimation(UpperCamelCase_							)
     model.load_state_dict(UpperCamelCase_							)
     model.eval()

     # Check outputs on an image
     snake_case											=							4_80 if '''ade''' in checkpoint_url else 3_84
     snake_case											=							DPTImageProcessor(size=UpperCamelCase_							)

     snake_case											=							prepare_img()
     snake_case											=							image_processor(UpperCamelCase_				,return_tensors='''pt'''							)

     # forward pass
     snake_case											=							model(**UpperCamelCase_							).logits if '''ade''' in checkpoint_url else model(**UpperCamelCase_							).predicted_depth

     # Assert logits
     snake_case											=							torch.tensor([[6.3199, 6.3629, 6.4148], [6.3850, 6.3615, 6.4166], [6.3519, 6.3176, 6.3575]]							)
     if "ade" in checkpoint_url:
          snake_case											=							torch.tensor([[4.0480, 4.2420, 4.4360], [4.3124, 4.5693, 4.8261], [4.5768, 4.8965, 5.2163]]							)
     assert outputs.shape == torch.Size(UpperCamelCase_							)
     assert (
         torch.allclose(outputs[0, 0, :3, :3]				,UpperCamelCase_				,atol=1e-4							)
         if "ade" in checkpoint_url
         else torch.allclose(outputs[0, :3, :3]				,UpperCamelCase_							)
     )

     Path(UpperCamelCase_							).mkdir(exist_ok=UpperCamelCase_							)
     print(F'''Saving model to {pytorch_dump_folder_path}'''							)
     model.save_pretrained(UpperCamelCase_							)
     print(F'''Saving image processor to {pytorch_dump_folder_path}'''							)
     image_processor.save_pretrained(UpperCamelCase_							)

     if push_to_hub:
          print('''Pushing model to hub...'''							)
          model.push_to_hub(
              repo_path_or_name=Path(UpperCamelCase_				,UpperCamelCase_							)				,organization='''nielsr'''				,commit_message='''Add model'''				,use_temp_dir=UpperCamelCase_				,)
          image_processor.push_to_hub(
              repo_path_or_name=Path(UpperCamelCase_				,UpperCamelCase_							)				,organization='''nielsr'''				,commit_message='''Add image processor'''				,use_temp_dir=UpperCamelCase_				,)


if __name__ == "__main__":
 _SCREAMING_SNAKE_CASE     :					Union[str, Any]      =       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=True,
     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.",
 )

 _SCREAMING_SNAKE_CASE     :					Dict      =       parser.parse_args()
 convert_dpt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name)








from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import (
     TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
     TFTransfoXLForSequenceClassification,
     TFTransfoXLLMHeadModel,
     TFTransfoXLModel,
 )

class     A__   :







    """simple docstring"""

    def __init__(			self     ,   __snake_case     ,   ):
         snake_case											=							parent
         snake_case											=							1_3
         snake_case											=							7
         snake_case											=							3_0
         snake_case											=							self.seq_length + self.mem_len
         snake_case											=							1_5
         snake_case											=							True
         snake_case											=							True
         snake_case											=							9_9
         snake_case											=							[1_0, 5_0, 8_0]
         snake_case											=							3_2
         snake_case											=							3_2
         snake_case											=							4
         snake_case											=							8
         snake_case											=							1_2_8
         snake_case											=							2
         snake_case											=							2
         snake_case											=							None
         snake_case											=							1
         snake_case											=							0
         snake_case											=							3
         snake_case											=							self.vocab_size - 1
         snake_case											=							0.01
    def 						a_     (			self       ):
         snake_case											=							ids_tensor([self.batch_size, self.seq_length]     ,   self.vocab_size       )
         snake_case											=							ids_tensor([self.batch_size, self.seq_length]     ,   self.vocab_size       )

         snake_case											=							None
         if self.use_labels:
              snake_case											=							ids_tensor([self.batch_size, self.seq_length]     ,   self.vocab_size       )

         snake_case											=							TransfoXLConfig(
             vocab_size=self.vocab_size     ,   mem_len=self.mem_len     ,   clamp_len=self.clamp_len     ,   cutoffs=self.cutoffs     ,   d_model=self.hidden_size     ,   d_embed=self.d_embed     ,   n_head=self.num_attention_heads     ,   d_head=self.d_head     ,   d_inner=self.d_inner     ,   div_val=self.div_val     ,   n_layer=self.num_hidden_layers     ,   eos_token_id=self.eos_token_id     ,   pad_token_id=self.vocab_size - 1     ,   init_range=self.init_range     ,   num_labels=self.num_labels     ,   )

         return (config, input_ids_a, input_ids_a, lm_labels)
    def 						a_     (			self       ):
         random.seed(self.seed       )
         tf.random.set_seed(self.seed       )
    def 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         snake_case											=							TFTransfoXLModel(__snake_case       )

         snake_case					,    snake_case											=							model(__snake_case       ).to_tuple()

         snake_case											=							{'''input_ids''': input_ids_a, '''mems''': mems_a}

         snake_case					,    snake_case											=							model(__snake_case       ).to_tuple()

         self.parent.assertEqual(hidden_states_a.shape     ,   (self.batch_size, self.seq_length, self.hidden_size)       )
         self.parent.assertEqual(hidden_states_a.shape     ,   (self.batch_size, self.seq_length, self.hidden_size)       )
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]     ,   [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers     ,   )
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]     ,   [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers     ,   )
    def 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         snake_case											=							TFTransfoXLLMHeadModel(__snake_case       )

         snake_case					,    snake_case											=							model(__snake_case       ).to_tuple()

         snake_case											=							{'''input_ids''': input_ids_a, '''labels''': lm_labels}
         snake_case					,    snake_case											=							model(__snake_case       ).to_tuple()

         snake_case					,    snake_case											=							model([input_ids_a, mems_a]       ).to_tuple()

         snake_case											=							{'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

         snake_case					,    snake_case											=							model(__snake_case       ).to_tuple()

         self.parent.assertEqual(lm_logits_a.shape     ,   (self.batch_size, self.seq_length, self.vocab_size)       )
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]     ,   [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers     ,   )

         self.parent.assertEqual(lm_logits_a.shape     ,   (self.batch_size, self.seq_length, self.vocab_size)       )
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]     ,   [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers     ,   )
    def 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         snake_case											=							TFTransfoXLForSequenceClassification(__snake_case       )
         snake_case											=							model(__snake_case       )
         self.parent.assertEqual(result.logits.shape     ,   (self.batch_size, self.num_labels)       )




    def 						a_     (			self       ):
         snake_case											=							self.prepare_config_and_inputs()
         ((snake_case)					,    (snake_case)					,    (snake_case)					,    (snake_case))											=							config_and_inputs
         snake_case											=							{'''input_ids''': input_ids_a}
         return config, inputs_dict






@require_tf
class     A__   (       snake_case__			,   snake_case__			,   unittest.TestCase      ):







    """simple docstring"""

    __magic_name__         =						(
        (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
    )
    __magic_name__         =						() if is_tf_available() else ()
    __magic_name__         =						(
        {
            'feature-extraction': TFTransfoXLModel,
            'text-classification': TFTransfoXLForSequenceClassification,
            'text-generation': TFTransfoXLLMHeadModel,
            'zero-shot': TFTransfoXLForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    # TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
    __magic_name__         =						False
    __magic_name__         =						False
    __magic_name__         =						False
    __magic_name__         =						False
    def 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         if pipeline_test_casse_name == "TextGenerationPipelineTests":
              # Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
              # `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
              # tokenizer.
              return True

         return False
    def 						a_     (			self       ):
         snake_case											=							TFTransfoXLModelTester(self       )
         snake_case											=							ConfigTester(self     ,   config_class=__snake_case     ,   d_embed=3_7       )
    def 						a_     (			self       ):
         self.config_tester.run_common_tests()
    def 						a_     (			self       ):
         self.model_tester.set_seed()
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_model(*__snake_case       )
    def 						a_     (			self       ):
         self.model_tester.set_seed()
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_lm_head(*__snake_case       )
    def 						a_     (			self       ):
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*__snake_case       )
    def 						a_     (			self       ):
         snake_case					,    snake_case											=							self.model_tester.prepare_config_and_inputs_for_common()
         snake_case											=							[TFTransfoXLForSequenceClassification]

         for model_class in self.all_model_classes:
              snake_case											=							model_class(__snake_case       )
              assert isinstance(model.get_input_embeddings()     ,   tf.keras.layers.Layer       )
              if model_class in list_other_models_with_output_ebd:
                   snake_case											=							model.get_output_embeddings()
                   assert isinstance(__snake_case     ,   tf.keras.layers.Layer       )
                   snake_case											=							model.get_bias()
                   assert name is None
              else:
                   snake_case											=							model.get_output_embeddings()
                   assert x is None
                   snake_case											=							model.get_bias()
                   assert name is None
    def 						a_     (			self       ):
         # TODO JP: Make TransfoXL XLA compliant
         pass
    @slow
    def 						a_     (			self       ):
         for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case											=							TFTransfoXLModel.from_pretrained(__snake_case       )
              self.assertIsNotNone(__snake_case       )




    @unittest.skip(reason='''This model doesn\'t play well with fit() due to not returning a single loss.'''       )
    def 						a_     (			self       ):
         pass






@require_tf
class     A__   (       unittest.TestCase      ):







    """simple docstring"""

    @unittest.skip('''Skip test until #12651 is resolved.'''       )
    @slow
    def 						a_     (			self       ):
         snake_case											=							TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''       )
         # fmt: off
         snake_case											=							tf.convert_to_tensor([[3_3,1_2_9_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_2,1_7_0_6,1_7,2_0_0_9_8,5,3_2_1_5,2_1,3_7,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,6_2_2_4,8_3_1,1_6_0_0_2,2,8,6_0_3,7_8_9_6_7,2_9_5_4_6,2_3,8_0_3,2_0,2_5,4_1_6,5,8,2_3_2,4,2_7_7,6,1_8_5_5,4_6_0_1,3,2_9_5_4_6,5_4,8,3_6_0_9,5,5_7_2_1_1,4_9,4,1,2_7_7,1_8,8,1_7_5_5,1_5_6_9_1,3,3_4_1,2_5,4_1_6,6_9_3,4_2_5_7_3,7_1,1_7,4_0_1,9_4,3_1,1_7_9_1_9,2,2_9_5_4_6,7_8_7_3,1_8,1,4_3_5,2_3,1_1_0_1_1,7_5_5,5,5_1_6_7,3,7_9_8_3,9_8,8_4,2,2_9_5_4_6,3_2_6_7,8,3_6_0_9,4,1,4_8_6_5,1_0_7_5,2,6_0_8_7,7_1,6,3_4_6,8,5_8_5_4,3,2_9_5_4_6,8_2_4,1_4_0_0,1_8_6_8,2,1_9,1_6_0,2,3_1_1,8,5_4_9_6,2,2_0_9_2_0,1_7,2_5,1_5_0_9_7,3,2_4,2_4,0]]     ,   dtype=tf.intaa       )  # noqa: E231
         # fmt: on
         #  In 1991 , the remains of Russian Tsar Nicholas II and his family
         #  ( except for Alexei and Maria ) are discovered .
         #  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
         #  remainder of the story . 1883 Western Siberia ,
         #  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
         #  Rasputin has a vision and denounces one of the men as a horse thief . Although his
         #  father initially slaps him for making such an accusation , Rasputin watches as the
         #  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
         #  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
         #  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

         # fmt: off
         snake_case											=							[3_3,1_2_9_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_2,1_7_0_6,1_7,2_0_0_9_8,5,3_2_1_5,2_1,3_7,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,6_2_2_4,8_3_1,1_6_0_0_2,2,8,6_0_3,7_8_9_6_7,2_9_5_4_6,2_3,8_0_3,2_0,2_5,4_1_6,5,8,2_3_2,4,2_7_7,6,1_8_5_5,4_6_0_1,3,2_9_5_4_6,5_4,8,3_6_0_9,5,5_7_2_1_1,4_9,4,1,2_7_7,1_8,8,1_7_5_5,1_5_6_9_1,3,3_4_1,2_5,4_1_6,6_9_3,4_2_5_7_3,7_1,1_7,4_0_1,9_4,3_1,1_7_9_1_9,2,2_9_5_4_6,7_8_7_3,1_8,1,4_3_5,2_3,1_1_0_1_1,7_5_5,5,5_1_6_7,3,7_9_8_3,9_8,8_4,2,2_9_5_4_6,3_2_6_7,8,3_6_0_9,4,1,4_8_6_5,1_0_7_5,2,6_0_8_7,7_1,6,3_4_6,8,5_8_5_4,3,2_9_5_4_6,8_2_4,1_4_0_0,1_8_6_8,2,1_9,1_6_0,2,3_1_1,8,5_4_9_6,2,2_0_9_2_0,1_7,2_5,1_5_0_9_7,3,2_4,2_4,0,3_3,1,1_8_5_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_8,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,0]  # noqa: E231
         # fmt: on
         #  In 1991, the remains of Russian Tsar Nicholas II and his family (
         #  except for Alexei and Maria ) are discovered. The voice of young son,
         #  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
         #  1883 Western Siberia, a young Grigori Rasputin is asked by his father
         #  and a group of men to perform magic. Rasputin has a vision and
         #  denounces one of the men as a horse thief. Although his father initially
         #  slaps him for making such an accusation, Rasputin watches as the man
         #  is chased outside and beaten. Twenty years later, Rasputin sees a vision
         #  of the Virgin Mary, prompting him to become a priest.
         #  Rasputin quickly becomes famous, with people, even a bishop, begging for
         #  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
         # Nicholas II and his family were discovered. The voice of <unk> young son,
         # Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

         snake_case											=							model.generate(__snake_case     ,   max_length=2_0_0     ,   do_sample=__snake_case       )
         self.assertListEqual(output_ids[0].numpy().tolist()     ,   __snake_case       )




