


import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPanoramaPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

@skip_mps
class        a	(_lowerCAmelCase  ,       _lowerCAmelCase  ,       unittest.TestCase   ):




							"""simple docstring"""


							__UpperCAmelCase					:							List[str]  						=						StableDiffusionPanoramaPipeline
							__UpperCAmelCase					:							Union[str, Any]  						=						TEXT_TO_IMAGE_PARAMS
							__UpperCAmelCase					:							Union[str, Any]  						=						TEXT_TO_IMAGE_BATCH_PARAMS
							__UpperCAmelCase					:							int  						=						TEXT_TO_IMAGE_IMAGE_PARAMS
							__UpperCAmelCase					:							Tuple  						=						TEXT_TO_IMAGE_IMAGE_PARAMS

							def 					__snake_case      (							self :						Optional[int]       )			->					List[str]:
														torch.manual_seed(0       )
														__snake_case	:    int											=     UNetaDConditionModel(
														    block_out_channels=(32, 64)					,			layers_per_block=1					,			sample_size=32					,			in_channels=4					,			out_channels=4					,			down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")					,			up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")					,			cross_attention_dim=32					,			)
														__snake_case	:    str											=     DDIMScheduler()
														torch.manual_seed(0       )
														__snake_case	:    Dict											=     AutoencoderKL(
														    block_out_channels=[32, 64]					,			in_channels=3					,			out_channels=3					,			down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]					,			up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]					,			latent_channels=4					,			)
														torch.manual_seed(0       )
														__snake_case	:    List[Any]											=     CLIPTextConfig(
														    bos_token_id=0					,			eos_token_id=2					,			hidden_size=32					,			intermediate_size=37					,			layer_norm_eps=1E-05					,			num_attention_heads=4					,			num_hidden_layers=5					,			pad_token_id=1					,			vocab_size=1000					,			)
														__snake_case	:    Dict											=     CLIPTextModel(lowerCamelCase       )
														__snake_case	:    Union[str, Any]											=     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"       )

														__snake_case	:    str											=     {
														    "unet": unet,
														    "scheduler": scheduler,
														    "vae": vae,
														    "text_encoder": text_encoder,
														    "tokenizer": tokenizer,
														    "safety_checker": None,
														    "feature_extractor": None,
														}
														return components

							def 					__snake_case      (							self :						Tuple					,			lowerCamelCase :						str					,			lowerCamelCase :						Any=0       )			->					List[Any]:
														__snake_case	:    Dict											=     torch.manual_seed(lowerCamelCase       )
														__snake_case	:    Any											=     {
														    "prompt": "a photo of the dolomites",
														    "generator": generator,
														    # Setting height and width to None to prevent OOMs on CPU.
														    "height": None,
														    "width": None,
														    "num_inference_steps": 1,
														    "guidance_scale": 6.0,
														    "output_type": "numpy",
														}
														return inputs

							def 					__snake_case      (							self :						str       )			->					int:
														__snake_case	:    List[Any]											=     "cpu"  # ensure determinism for the device-dependent torch.Generator
														__snake_case	:    Dict											=     self.get_dummy_components()
														__snake_case	:    Union[str, Any]											=     StableDiffusionPanoramaPipeline(**lowerCamelCase       )
														__snake_case	:    int											=     sd_pipe.to(lowerCamelCase       )
														sd_pipe.set_progress_bar_config(disable=lowerCamelCase       )

														__snake_case	:    Tuple											=     self.get_dummy_inputs(lowerCamelCase       )
														__snake_case	:    Union[str, Any]											=     sd_pipe(**lowerCamelCase       ).images
														__snake_case	:    List[str]											=     image[0, -3:, -3:, -1]
														assert image.shape == (1, 64, 64, 3)

														__snake_case	:    List[Any]											=     np.array([0.61_86, 0.53_74, 0.49_15, 0.41_35, 0.41_14, 0.45_63, 0.51_28, 0.49_77, 0.47_57]       )

														assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2

							def 					__snake_case      (							self :						Tuple       )			->					List[str]:
														super().test_inference_batch_consistent(batch_sizes=[1, 2]       )

							def 					__snake_case      (							self :						str       )			->					int:
														super().test_inference_batch_single_identical(batch_size=2					,			expected_max_diff=3.25E-3       )

							def 					__snake_case      (							self :						int       )			->					str:
														__snake_case	:    List[str]											=     "cpu"  # ensure determinism for the device-dependent torch.Generator
														__snake_case	:    Union[str, Any]											=     self.get_dummy_components()
														__snake_case	:    List[str]											=     StableDiffusionPanoramaPipeline(**lowerCamelCase       )
														__snake_case	:    int											=     sd_pipe.to(lowerCamelCase       )
														sd_pipe.set_progress_bar_config(disable=lowerCamelCase       )

														__snake_case	:    Optional[int]											=     self.get_dummy_inputs(lowerCamelCase       )
														__snake_case	:    Optional[int]											=     "french fries"
														__snake_case	:    Optional[Any]											=     sd_pipe(**lowerCamelCase					,			negative_prompt=lowerCamelCase       )
														__snake_case	:    int											=     output.images
														__snake_case	:    List[str]											=     image[0, -3:, -3:, -1]

														assert image.shape == (1, 64, 64, 3)

														__snake_case	:    List[Any]											=     np.array([0.61_87, 0.53_75, 0.49_15, 0.41_36, 0.41_14, 0.45_63, 0.51_28, 0.49_76, 0.47_57]       )

														assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2

							def 					__snake_case      (							self :						List[Any]       )			->					Dict:
														__snake_case	:    Tuple											=     "cpu"  # ensure determinism for the device-dependent torch.Generator
														__snake_case	:    Union[str, Any]											=     self.get_dummy_components()
														__snake_case	:    Tuple											=     StableDiffusionPanoramaPipeline(**lowerCamelCase       )
														__snake_case	:    Union[str, Any]											=     sd_pipe.to(lowerCamelCase       )
														sd_pipe.set_progress_bar_config(disable=lowerCamelCase       )

														__snake_case	:    Tuple											=     self.get_dummy_inputs(lowerCamelCase       )
														__snake_case	:    int											=     sd_pipe(**lowerCamelCase					,			view_batch_size=2       )
														__snake_case	:    Any											=     output.images
														__snake_case	:    str											=     image[0, -3:, -3:, -1]

														assert image.shape == (1, 64, 64, 3)

														__snake_case	:    Optional[int]											=     np.array([0.61_87, 0.53_75, 0.49_15, 0.41_36, 0.41_14, 0.45_63, 0.51_28, 0.49_76, 0.47_57]       )

														assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2

							def 					__snake_case      (							self :						Dict       )			->					int:
														__snake_case	:    str											=     "cpu"  # ensure determinism for the device-dependent torch.Generator
														__snake_case	:    List[str]											=     self.get_dummy_components()
														__snake_case	:    Any											=     EulerAncestralDiscreteScheduler(
														    beta_start=0.0_00_85					,			beta_end=0.0_12					,			beta_schedule="scaled_linear"       )
														__snake_case	:    List[Any]											=     StableDiffusionPanoramaPipeline(**lowerCamelCase       )
														__snake_case	:    List[Any]											=     sd_pipe.to(lowerCamelCase       )
														sd_pipe.set_progress_bar_config(disable=lowerCamelCase       )

														__snake_case	:    List[str]											=     self.get_dummy_inputs(lowerCamelCase       )
														__snake_case	:    str											=     sd_pipe(**lowerCamelCase       ).images
														__snake_case	:    Any											=     image[0, -3:, -3:, -1]

														assert image.shape == (1, 64, 64, 3)

														__snake_case	:    List[Any]											=     np.array([0.40_24, 0.65_10, 0.49_01, 0.53_78, 0.58_13, 0.56_22, 0.47_95, 0.44_67, 0.49_52]       )

														assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2






							def 					__snake_case      (							self :						Optional[int]       )			->					Tuple:
														__snake_case	:    Dict											=     "cpu"  # ensure determinism for the device-dependent torch.Generator
														__snake_case	:    List[str]											=     self.get_dummy_components()
														__snake_case	:    Tuple											=     PNDMScheduler(
														    beta_start=0.0_00_85					,			beta_end=0.0_12					,			beta_schedule="scaled_linear"					,			skip_prk_steps=lowerCamelCase       )
														__snake_case	:    Dict											=     StableDiffusionPanoramaPipeline(**lowerCamelCase       )
														__snake_case	:    List[Any]											=     sd_pipe.to(lowerCamelCase       )
														sd_pipe.set_progress_bar_config(disable=lowerCamelCase       )

														__snake_case	:    Optional[Any]											=     self.get_dummy_inputs(lowerCamelCase       )
														__snake_case	:    Union[str, Any]											=     sd_pipe(**lowerCamelCase       ).images
														__snake_case	:    Any											=     image[0, -3:, -3:, -1]

														assert image.shape == (1, 64, 64, 3)

														__snake_case	:    Any											=     np.array([0.63_91, 0.62_91, 0.48_61, 0.51_34, 0.55_52, 0.45_78, 0.50_32, 0.50_23, 0.45_39]       )

														assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2

@slow
@require_torch_gpu
class        a	(unittest.TestCase   ):




							"""simple docstring"""


							def 					__snake_case      (							self :						Union[str, Any]       )			->					str:
														super().tearDown()
														gc.collect()
														torch.cuda.empty_cache()

							def 					__snake_case      (							self :						int					,			lowerCamelCase :						Optional[Any]=0       )			->					List[Any]:
														__snake_case	:    Any											=     torch.manual_seed(lowerCamelCase       )
														__snake_case	:    Optional[Any]											=     {
														    "prompt": "a photo of the dolomites",
														    "generator": generator,
														    "num_inference_steps": 3,
														    "guidance_scale": 7.5,
														    "output_type": "numpy",
														}
														return inputs

							def 					__snake_case      (							self :						int       )			->					List[Any]:
														__snake_case	:    str											=     "stabilityai/stable-diffusion-2-base"
														__snake_case	:    Any											=     DDIMScheduler.from_pretrained(lowerCamelCase					,			subfolder="scheduler"       )
														__snake_case	:    Dict											=     StableDiffusionPanoramaPipeline.from_pretrained(lowerCamelCase					,			scheduler=lowerCamelCase					,			safety_checker=lowerCamelCase       )
														pipe.to(lowerCamelCase       )
														pipe.set_progress_bar_config(disable=lowerCamelCase       )
														pipe.enable_attention_slicing()

														__snake_case	:    Tuple											=     self.get_inputs()
														__snake_case	:    int											=     pipe(**lowerCamelCase       ).images
														__snake_case	:    Optional[Any]											=     image[0, -3:, -3:, -1].flatten()

														assert image.shape == (1, 512, 2048, 3)

														__snake_case	:    int											=     np.array(
														    [
														        0.36_96_83_92,
														        0.27_02_53_72,
														        0.32_44_67_66,
														        0.28_37_93_87,
														        0.36_36_32_74,
														        0.30_73_33_47,
														        0.27_10_00_27,
														        0.27_05_41_25,
														        0.25_53_60_96,
														    ]       )

														assert np.abs(expected_slice - image_slice       ).max() < 1E-2

							def 					__snake_case      (							self :						Tuple       )			->					Union[str, Any]:
														__snake_case	:    Optional[int]											=     StableDiffusionPanoramaPipeline.from_pretrained(
														    "stabilityai/stable-diffusion-2-base"					,			safety_checker=lowerCamelCase       )
														__snake_case	:    Dict											=     LMSDiscreteScheduler.from_config(pipe.scheduler.config       )
														pipe.to(lowerCamelCase       )
														pipe.set_progress_bar_config(disable=lowerCamelCase       )
														pipe.enable_attention_slicing()

														__snake_case	:    Dict											=     self.get_inputs()
														__snake_case	:    int											=     pipe(**lowerCamelCase       ).images
														__snake_case	:    Optional[int]											=     image[0, -3:, -3:, -1].flatten()

														assert image.shape == (1, 512, 2048, 3)

														__snake_case	:    Tuple											=     np.array(
														    [
														        [
														            0.0,
														            0.0,
														            0.0,
														            0.0,
														            0.0,
														            0.0,
														            0.0,
														            0.0,
														            0.0,
														        ]
														    ]       )

														assert np.abs(expected_slice - image_slice       ).max() < 1E-3

							def 					__snake_case      (							self :						Any       )			->					Optional[int]:
														__snake_case	:    Union[str, Any]											=     0

														def callback_fn(lowerCamelCase :						int					,			lowerCamelCase :						int					,			lowerCamelCase :						torch.FloatTensor       ) -> None:
																					__snake_case	:    List[Any]											=     True
																					nonlocal number_of_steps
																					number_of_steps += 1
																					if step == 1:
																												__snake_case	:    Optional[int]											=     latents.detach().cpu().numpy()
																												assert latents.shape == (1, 4, 64, 256)
																												__snake_case	:    Dict											=     latents[0, -3:, -3:, -1]

																												__snake_case	:    Tuple											=     np.array(
																												    [
																												        0.18_68_18_69,
																												        0.33_90_78_16,
																												        0.5_36_12_76,
																												        0.14_43_28_65,
																												        -0.02_85_66_11,
																												        -0.73_94_11_23,
																												        0.23_39_79_87,
																												        0.47_32_26_82,
																												        -0.37_82_31_64,
																												    ]       )
																												assert np.abs(latents_slice.flatten() - expected_slice       ).max() < 5E-2
																					elif step == 2:
																												__snake_case	:    int											=     latents.detach().cpu().numpy()
																												assert latents.shape == (1, 4, 64, 256)
																												__snake_case	:    Dict											=     latents[0, -3:, -3:, -1]

																												__snake_case	:    List[Any]											=     np.array(
																												    [
																												        0.18_53_96_45,
																												        0.33_98_72_48,
																												        0.5_37_85_59,
																												        0.14_43_71_42,
																												        -0.02_45_52_61,
																												        -0.7_33_83_17,
																												        0.23_99_07_55,
																												        0.47_35_62_72,
																												        -0.3_78_65_05,
																												    ]       )

																												assert np.abs(latents_slice.flatten() - expected_slice       ).max() < 5E-2

														__snake_case	:    Dict											=     False

														__snake_case	:    Optional[Any]											=     "stabilityai/stable-diffusion-2-base"
														__snake_case	:    str											=     DDIMScheduler.from_pretrained(lowerCamelCase					,			subfolder="scheduler"       )
														__snake_case	:    Optional[int]											=     StableDiffusionPanoramaPipeline.from_pretrained(lowerCamelCase					,			scheduler=lowerCamelCase					,			safety_checker=lowerCamelCase       )
														__snake_case	:    Optional[Any]											=     pipe.to(lowerCamelCase       )
														pipe.set_progress_bar_config(disable=lowerCamelCase       )
														pipe.enable_attention_slicing()

														__snake_case	:    Dict											=     self.get_inputs()
														pipe(**lowerCamelCase					,			callback=lowerCamelCase					,			callback_steps=1       )
														assert callback_fn.has_been_called
														assert number_of_steps == 3






							def 					__snake_case      (							self :						Any       )			->					Any:
														torch.cuda.empty_cache()
														torch.cuda.reset_max_memory_allocated()
														torch.cuda.reset_peak_memory_stats()

														__snake_case	:    Optional[Any]											=     "stabilityai/stable-diffusion-2-base"
														__snake_case	:    Optional[int]											=     DDIMScheduler.from_pretrained(lowerCamelCase					,			subfolder="scheduler"       )
														__snake_case	:    Union[str, Any]											=     StableDiffusionPanoramaPipeline.from_pretrained(lowerCamelCase					,			scheduler=lowerCamelCase					,			safety_checker=lowerCamelCase       )
														__snake_case	:    Any											=     pipe.to(lowerCamelCase       )
														pipe.set_progress_bar_config(disable=lowerCamelCase       )
														pipe.enable_attention_slicing(1       )
														pipe.enable_sequential_cpu_offload()

														__snake_case	:    int											=     self.get_inputs()
														__snake_case	:    Any											=     pipe(**lowerCamelCase       )

														__snake_case	:    Optional[int]											=     torch.cuda.max_memory_allocated()
														# make sure that less than 5.2 GB is allocated
														assert mem_bytes < 5.5 * 10**9





import unittest

from transformers import BertGenerationTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


_snake_case  :	Optional[int]			      =       "▁"

_snake_case  :	Tuple			      =       get_tests_dir("fixtures/test_sentencepiece.model")

@require_sentencepiece
class        a	(_lowerCAmelCase  ,       unittest.TestCase   ):




							"""simple docstring"""


							__UpperCAmelCase					:							Optional[Any]  						=						BertGenerationTokenizer
							__UpperCAmelCase					:							List[Any]  						=						False
							__UpperCAmelCase					:							List[Any]  						=						True

							def 					__snake_case      (							self :						Optional[int]       )			->					Optional[int]:
														super().setUp()

														__snake_case	:    Tuple											=     BertGenerationTokenizer(lowerCamelCase					,			keep_accents=lowerCamelCase       )
														tokenizer.save_pretrained(self.tmpdirname       )

							def 					__snake_case      (							self :						Dict       )			->					int:
														__snake_case	:    str											=     "<s>"
														__snake_case	:    Any											=     1

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

							def 					__snake_case      (							self :						str       )			->					Optional[Any]:
														__snake_case	:    int											=     list(self.get_tokenizer().get_vocab().keys()       )

														self.assertEqual(vocab_keys[0]					,			"<unk>"       )
														self.assertEqual(vocab_keys[1]					,			"<s>"       )
														self.assertEqual(vocab_keys[-1]					,			"<pad>"       )
														self.assertEqual(len(lowerCamelCase       )					,			1002       )

							def 					__snake_case      (							self :						List[str]       )			->					Optional[int]:
														self.assertEqual(self.get_tokenizer().vocab_size					,			1000       )

							def 					__snake_case      (							self :						List[str]       )			->					Union[str, Any]:
														__snake_case	:    List[Any]											=     BertGenerationTokenizer(lowerCamelCase					,			keep_accents=lowerCamelCase       )

														__snake_case	:    int											=     tokenizer.tokenize("This is a test"       )
														self.assertListEqual(lowerCamelCase					,			["▁This", "▁is", "▁a", "▁t", "est"]       )

														self.assertListEqual(
														    tokenizer.convert_tokens_to_ids(lowerCamelCase       )					,			[285, 46, 10, 170, 382]					,			)

														__snake_case	:    str											=     tokenizer.tokenize("I was born in 92000, and this is falsé."       )
														self.assertListEqual(
														    lowerCamelCase					,			[
														        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",
														        "é",
														        ".",
														    ]					,			)
														__snake_case	:    Any											=     tokenizer.convert_tokens_to_ids(lowerCamelCase       )
														self.assertListEqual(
														    lowerCamelCase					,			[8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]					,			)

														__snake_case	:    Optional[Any]											=     tokenizer.convert_ids_to_tokens(lowerCamelCase       )
														self.assertListEqual(
														    lowerCamelCase					,			[
														        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 					__snake_case      (							self :						str       )			->					List[Any]:
														return BertGenerationTokenizer.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder"       )

							@slow
							def 					__snake_case      (							self :						Tuple       )			->					Union[str, Any]:
														__snake_case	:    Union[str, Any]											=     "Hello World!"
														__snake_case	:    List[str]											=     [18536, 2260, 101]

														self.assertListEqual(lowerCamelCase					,			self.big_tokenizer.encode(lowerCamelCase       )       )

							@slow
							def 					__snake_case      (							self :						str       )			->					Optional[int]:
														__snake_case	:    List[Any]											=     (
														    "This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will"
														    " add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth"
														)
														__snake_case	:    Any											=     [
														    871,
														    419,
														    358,
														    946,
														    991,
														    2521,
														    452,
														    358,
														    1357,
														    387,
														    7751,
														    3536,
														    112,
														    985,
														    456,
														    126,
														    865,
														    938,
														    5400,
														    5734,
														    458,
														    1368,
														    467,
														    786,
														    2462,
														    5246,
														    1159,
														    633,
														    865,
														    4519,
														    457,
														    582,
														    852,
														    2557,
														    427,
														    916,
														    508,
														    405,
														    34324,
														    497,
														    391,
														    408,
														    11342,
														    1244,
														    385,
														    100,
														    938,
														    985,
														    456,
														    574,
														    362,
														    12597,
														    3200,
														    3129,
														    1172,
														]

														self.assertListEqual(lowerCamelCase					,			self.big_tokenizer.encode(lowerCamelCase       )       )

							@require_torch
							@slow
							def 					__snake_case      (							self :						Optional[Any]       )			->					str:
														import torch

														from transformers import BertGenerationConfig, BertGenerationEncoder

														# Build sequence
														__snake_case	:    List[Any]											=     list(self.big_tokenizer.get_vocab().keys()       )[:10]
														__snake_case	:    Union[str, Any]											=     " ".join(lowerCamelCase       )
														__snake_case	:    Optional[int]											=     self.big_tokenizer.encode_plus(lowerCamelCase					,			return_tensors="pt"					,			return_token_type_ids=lowerCamelCase       )
														__snake_case	:    Optional[Any]											=     self.big_tokenizer.batch_encode_plus(
														    [sequence + " " + sequence]					,			return_tensors="pt"					,			return_token_type_ids=lowerCamelCase       )

														__snake_case	:    List[Any]											=     BertGenerationConfig()
														__snake_case	:    Dict											=     BertGenerationEncoder(lowerCamelCase       )

														assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

														with torch.no_grad():
																					model(**lowerCamelCase       )
																					model(**lowerCamelCase       )






							@slow
							def 					__snake_case      (							self :						List[Any]       )			->					List[Any]:
														# fmt: off
														__snake_case	:    Optional[Any]											=     {"input_ids": [[39286, 458, 36335, 2001, 456, 13073, 13266, 455, 113, 7746, 1741, 11157, 391, 13073, 13266, 455, 113, 3967, 35412, 113, 4936, 109, 3870, 2377, 113, 30084, 45720, 458, 134, 17496, 112, 503, 11672, 113, 118, 112, 5665, 13347, 38687, 112, 1496, 31389, 112, 3268, 47264, 134, 962, 112, 16377, 8035, 23130, 430, 12169, 15518, 28592, 458, 146, 41697, 109, 391, 12169, 15518, 16689, 458, 146, 41358, 109, 452, 726, 4034, 111, 763, 35412, 5082, 388, 1903, 111, 9051, 391, 2870, 48918, 1900, 1123, 550, 998, 112, 9586, 15985, 455, 391, 410, 22955, 37636, 114], [448, 17496, 419, 3663, 385, 763, 113, 27533, 2870, 3283, 13043, 1639, 24713, 523, 656, 24013, 18550, 2521, 517, 27014, 21244, 420, 1212, 1465, 391, 927, 4833, 388, 578, 11786, 114, 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], [484, 2169, 7687, 21932, 18146, 726, 363, 17032, 3391, 114, 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, 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, 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=lowerCamelCase					,			model_name="google/bert_for_seq_generation_L-24_bbc_encoder"					,			revision="c817d1fd1be2ffa69431227a1fe320544943d4db"					,			)

