import unittest

from transformers import DebertaVaTokenizer, DebertaVaTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


UpperCAmelCase_								=							get_tests_dir('''fixtures/spiece.model''')





@require_sentencepiece
@require_tokenizers
class      lowerCAmelCase						(					__lowercase			,		unittest.TestCase			):
					_SCREAMING_SNAKE_CASE     :     List[Any]		=DebertaVaTokenizer
					_SCREAMING_SNAKE_CASE     :     List[Any]		=DebertaVaTokenizerFast
					_SCREAMING_SNAKE_CASE     :     Optional[int]		=True
					_SCREAMING_SNAKE_CASE     :     Union[str, Any]		=True



					def 			a__  (					self       ):
												super().setUp()

												# We have a SentencePiece fixture for testing
												_A=	DebertaVaTokenizer(__A				,      unk_token='<unk>'       )
												tokenizer.save_pretrained(self.tmpdirname       )



					def 			a__  (					self				,      lowerCAmelCase__       ):
												_A=	'this is a test'
												_A=	'this is a test'
												return input_text, output_text



					def 			a__  (					self       ):
												_A=	'<pad>'
												_A=	0

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



					def 			a__  (					self       ):
												_A=	list(self.get_tokenizer().get_vocab().keys()       )
												self.assertEqual(vocab_keys[0]				,      '<pad>'       )
												self.assertEqual(vocab_keys[1]				,      '<unk>'       )
												self.assertEqual(vocab_keys[-1]				,      '[PAD]'       )
												self.assertEqual(len(__A       )				,      30001       )



					def 			a__  (					self       ):
												self.assertEqual(self.get_tokenizer().vocab_size				,      30000       )



					def 			a__  (					self       ):
												# fmt: off
												_A=	' \tHeLLo!how  \n Are yoU?  '
												_A=	['▁hello', '!', 'how', '▁are', '▁you', '?']
												# fmt: on

												_A=	DebertaVaTokenizer(__A				,      do_lower_case=__A       )
												_A=	tokenizer.convert_ids_to_tokens(tokenizer.encode(__A				,      add_special_tokens=__A       )       )

												self.assertListEqual(__A				,      __A       )

												_A=	DebertaVaTokenizerFast(__A				,      do_lower_case=__A       )
												_A=	rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__A				,      add_special_tokens=__A       )       )

												self.assertListEqual(__A				,      __A       )



					@unittest.skip('There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.'       )
					def 			a__  (					self       ):
												pass



					@unittest.skip('There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.'       )
					def 			a__  (					self       ):
												pass



					def 			a__  (					self       ):
												# fmt: off
												_A=	'I was born in 92000, and this is falsé.'
												_A=	['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
												# fmt: on

												_A=	DebertaVaTokenizer(__A				,      split_by_punct=__A       )
												_A=	tokenizer.convert_ids_to_tokens(tokenizer.encode(__A				,      add_special_tokens=__A       )       )

												self.assertListEqual(__A				,      __A       )

												_A=	DebertaVaTokenizerFast(__A				,      split_by_punct=__A       )
												_A=	rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__A				,      add_special_tokens=__A       )       )

												self.assertListEqual(__A				,      __A       )



					def 			a__  (					self       ):
												# fmt: off
												_A=	'I was born in 92000, and this is falsé.'
												_A=	['▁i', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
												# fmt: on

												_A=	DebertaVaTokenizer(__A				,      do_lower_case=__A				,      split_by_punct=__A       )
												_A=	tokenizer.convert_ids_to_tokens(tokenizer.encode(__A				,      add_special_tokens=__A       )       )
												self.assertListEqual(__A				,      __A       )

												_A=	DebertaVaTokenizerFast(__A				,      do_lower_case=__A				,      split_by_punct=__A       )
												_A=	rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__A				,      add_special_tokens=__A       )       )
												self.assertListEqual(__A				,      __A       )



					def 			a__  (					self       ):
												# fmt: off
												_A=	'I was born in 92000, and this is falsé.'
												_A=	['▁i', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '.', ]
												# fmt: on

												_A=	DebertaVaTokenizer(__A				,      do_lower_case=__A				,      split_by_punct=__A       )
												_A=	tokenizer.convert_ids_to_tokens(tokenizer.encode(__A				,      add_special_tokens=__A       )       )

												self.assertListEqual(__A				,      __A       )

												_A=	DebertaVaTokenizerFast(__A				,      do_lower_case=__A				,      split_by_punct=__A       )
												_A=	rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__A				,      add_special_tokens=__A       )       )

												self.assertListEqual(__A				,      __A       )



					def 			a__  (					self       ):
												# fmt: off
												_A=	'I was born in 92000, and this is falsé.'
												_A=	['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
												# fmt: on

												_A=	DebertaVaTokenizer(__A				,      do_lower_case=__A				,      split_by_punct=__A       )
												_A=	tokenizer.convert_ids_to_tokens(tokenizer.encode(__A				,      add_special_tokens=__A       )       )

												self.assertListEqual(__A				,      __A       )

												_A=	DebertaVaTokenizerFast(__A				,      do_lower_case=__A				,      split_by_punct=__A       )
												_A=	rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__A				,      add_special_tokens=__A       )       )

												self.assertListEqual(__A				,      __A       )



					def 			a__  (					self       ):
												# fmt: off
												_A=	' \tHeLLo!how  \n Are yoU?  '
												_A=	['▁', '<unk>', 'e', '<unk>', 'o', '!', 'how', '▁', '<unk>', 're', '▁yo', '<unk>', '?']
												# fmt: on

												_A=	DebertaVaTokenizer(__A				,      do_lower_case=__A				,      split_by_punct=__A       )
												_A=	tokenizer.convert_ids_to_tokens(tokenizer.encode(__A				,      add_special_tokens=__A       )       )

												self.assertListEqual(__A				,      __A       )

												_A=	DebertaVaTokenizerFast(__A				,      do_lower_case=__A				,      split_by_punct=__A       )
												_A=	rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__A				,      add_special_tokens=__A       )       )

												self.assertListEqual(__A				,      __A       )



					def 			a__  (					self       ):
												_A=	self.get_tokenizer()
												_A=	self.get_rust_tokenizer()

												_A=	'I was born in 92000, and this is falsé.'

												_A=	tokenizer.convert_ids_to_tokens(tokenizer.encode(__A				,      add_special_tokens=__A       )       )
												_A=	rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(__A				,      add_special_tokens=__A       )       )
												self.assertListEqual(__A				,      __A       )

												_A=	tokenizer.encode(__A				,      add_special_tokens=__A       )
												_A=	rust_tokenizer.encode(__A				,      add_special_tokens=__A       )
												self.assertListEqual(__A				,      __A       )

												_A=	self.get_rust_tokenizer()
												_A=	tokenizer.encode(__A       )
												_A=	rust_tokenizer.encode(__A       )
												self.assertListEqual(__A				,      __A       )



					def 			a__  (					self       ):
												_A=	'This is a test'
												_A=	[13, 1, 4398, 25, 21, 1289]
												_A=	['▁', 'T', 'his', '▁is', '▁a', '▁test']
												_A=	['▁', '<unk>', 'his', '▁is', '▁a', '▁test']

												_A=	DebertaVaTokenizer(__A				,      keep_accents=__A       )
												_A=	DebertaVaTokenizerFast(__A				,      keep_accents=__A       )

												_A=	tokenizer.encode(__A				,      add_special_tokens=__A       )
												self.assertListEqual(__A				,      __A       )
												_A=	tokenizer.tokenize(__A       )
												self.assertListEqual(__A				,      __A       )
												_A=	tokenizer.convert_ids_to_tokens(__A       )
												self.assertListEqual(__A				,      __A       )

												_A=	rust_tokenizer.encode(__A				,      add_special_tokens=__A       )
												self.assertListEqual(__A				,      __A       )
												_A=	rust_tokenizer.tokenize(__A       )
												self.assertListEqual(__A				,      __A       )
												_A=	rust_tokenizer.convert_ids_to_tokens(__A       )
												self.assertListEqual(__A				,      __A       )

												# fmt: off
												_A=	'I was born in 92000, and this is falsé.'
												_A=	[13, 1, 23, 386, 19, 561, 3050, 15, 17, 48, 25, 8256, 18, 1, 9]
												_A=	['▁', 'I', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', 'é', '.', ]
												_A=	['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '.', ]
												# fmt: on

												_A=	tokenizer.encode(__A				,      add_special_tokens=__A       )
												self.assertListEqual(__A				,      __A       )
												_A=	tokenizer.tokenize(__A       )
												self.assertListEqual(__A				,      __A       )
												_A=	tokenizer.convert_ids_to_tokens(__A       )
												self.assertListEqual(__A				,      __A       )

												_A=	rust_tokenizer.encode(__A				,      add_special_tokens=__A       )
												self.assertListEqual(__A				,      __A       )
												_A=	rust_tokenizer.tokenize(__A       )
												self.assertListEqual(__A				,      __A       )
												_A=	rust_tokenizer.convert_ids_to_tokens(__A       )
												self.assertListEqual(__A				,      __A       )



					def 			a__  (					self       ):
												_A=	DebertaVaTokenizer(__A       )

												_A=	tokenizer.encode('sequence builders'       )
												_A=	tokenizer.encode('multi-sequence build'       )

												_A=	tokenizer.build_inputs_with_special_tokens(__A       )
												_A=	tokenizer.build_inputs_with_special_tokens(__A				,      __A       )

												self.assertEqual([tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]				,      __A       )
												self.assertEqual(
												    [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [tokenizer.sep_token_id]				,      __A				,      )





					@slow
					def 			a__  (					self       ):
												# fmt: off
												_A=	{'input_ids': [[1, 39867, 36, 19390, 486, 27, 35052, 81436, 18, 60685, 1225, 7, 35052, 81436, 18, 9367, 16899, 18, 15937, 53, 594, 773, 18, 16287, 30465, 36, 15937, 6, 41139, 38, 36979, 60763, 191, 6, 34132, 99, 6, 50538, 390, 43230, 6, 34132, 2779, 20850, 14, 699, 1072, 1194, 36, 382, 10901, 53, 7, 699, 1072, 2084, 36, 20422, 630, 53, 19, 105, 3049, 1896, 1053, 16899, 1506, 11, 37978, 4243, 7, 1237, 31869, 200, 16566, 654, 6, 35052, 81436, 7, 55630, 13593, 4, 2], [1, 26, 15011, 13, 667, 8, 1053, 18, 23611, 1237, 72356, 12820, 34, 104134, 1209, 35, 13313, 6627, 21, 202, 347, 7, 164, 2399, 11, 46, 4485, 4, 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], [1, 5, 1232, 2864, 15785, 14951, 105, 5, 8581, 1250, 4, 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]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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=__A				,      model_name='microsoft/deberta-v2-xlarge'				,      revision='ad6e42c1532ddf3a15c39246b63f5559d558b670'				,      )
import gc
import unittest

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

from diffusers import AltDiffusionPipeline, AutoencoderKL, DDIMScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

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


enable_full_determinism()





class      lowerCAmelCase						(					_a			,		_a			,		_a			,		unittest.TestCase			):
     _SCREAMING_SNAKE_CASE     :     Optional[int]		=AltDiffusionPipeline
     _SCREAMING_SNAKE_CASE     :     int		=TEXT_TO_IMAGE_PARAMS
     _SCREAMING_SNAKE_CASE     :     List[Any]		=TEXT_TO_IMAGE_BATCH_PARAMS
     _SCREAMING_SNAKE_CASE     :     Dict		=TEXT_TO_IMAGE_IMAGE_PARAMS
     _SCREAMING_SNAKE_CASE     :     Any		=TEXT_TO_IMAGE_IMAGE_PARAMS



     def 			a__  (					self       ):
            torch.manual_seed(0       )
            _A=	UNetaDConditionModel(
                block_out_channels=(32, 64)				,      layers_per_block=2				,      sample_size=32				,      in_channels=4				,      out_channels=4				,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')				,      up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')				,      cross_attention_dim=32				,      )
            _A=	DDIMScheduler(
                beta_start=0.00085				,      beta_end=0.012				,      beta_schedule='scaled_linear'				,      clip_sample=lowerCAmelCase__				,      set_alpha_to_one=lowerCAmelCase__				,      )
            torch.manual_seed(0       )
            _A=	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				,      )

            # TODO: address the non-deterministic text encoder (fails for save-load tests)
            # torch.manual_seed(0)
            # text_encoder_config = RobertaSeriesConfig(
            #     hidden_size=32,
            #     project_dim=32,
            #     intermediate_size=37,
            #     layer_norm_eps=1e-05,
            #     num_attention_heads=4,
            #     num_hidden_layers=5,
            #     vocab_size=5002,
            # )
            # text_encoder = RobertaSeriesModelWithTransformation(text_encoder_config)

            torch.manual_seed(0       )
            _A=	CLIPTextConfig(
                bos_token_id=0				,      eos_token_id=2				,      hidden_size=32				,      projection_dim=32				,      intermediate_size=37				,      layer_norm_eps=1E-05				,      num_attention_heads=4				,      num_hidden_layers=5				,      pad_token_id=1				,      vocab_size=5002				,      )
            _A=	CLIPTextModel(lowerCAmelCase__       )

            _A=	XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta'       )
            _A=	77

            _A=	{
                'unet': unet,
                'scheduler': scheduler,
                'vae': vae,
                'text_encoder': text_encoder,
                'tokenizer': tokenizer,
                'safety_checker': None,
                'feature_extractor': None,
            }
            return components



     def 			a__  (					self				,      lowerCAmelCase__				,      lowerCAmelCase__=0       ):
            if str(lowerCAmelCase__       ).startswith('mps'       ):
                   _A=	torch.manual_seed(lowerCAmelCase__       )
            else:
                   _A=	torch.Generator(device=lowerCAmelCase__       ).manual_seed(lowerCAmelCase__       )
            _A=	{
                'prompt': 'A painting of a squirrel eating a burger',
                'generator': generator,
                'num_inference_steps': 2,
                'guidance_scale': 6.0,
                'output_type': 'numpy',
            }
            return inputs



     def 			a__  (					self       ):
            super().test_attention_slicing_forward_pass(expected_max_diff=3E-3       )



     def 			a__  (					self       ):
            super().test_inference_batch_single_identical(expected_max_diff=3E-3       )



     def 			a__  (					self       ):
            _A=	'cpu'  # ensure determinism for the device-dependent torch.Generator

            _A=	self.get_dummy_components()
            torch.manual_seed(0       )
            _A=	RobertaSeriesConfig(
                hidden_size=32				,      project_dim=32				,      intermediate_size=37				,      layer_norm_eps=1E-05				,      num_attention_heads=4				,      num_hidden_layers=5				,      vocab_size=5002				,      )
            # TODO: remove after fixing the non-deterministic text encoder
            _A=	RobertaSeriesModelWithTransformation(lowerCAmelCase__       )
            _A=	text_encoder

            _A=	AltDiffusionPipeline(**lowerCAmelCase__       )
            _A=	alt_pipe.to(lowerCAmelCase__       )
            alt_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

            _A=	self.get_dummy_inputs(lowerCAmelCase__       )
            _A=	'A photo of an astronaut'
            _A=	alt_pipe(**lowerCAmelCase__       )
            _A=	output.images
            _A=	image[0, -3:, -3:, -1]

            assert image.shape == (1, 64, 64, 3)
            _A=	np.array(
                [0.5748162, 0.60447145, 0.48821217, 0.50100636, 0.5431185, 0.45763683, 0.49657696, 0.48132733, 0.47573093]       )

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





     def 			a__  (					self       ):
            _A=	'cpu'  # ensure determinism for the device-dependent torch.Generator

            _A=	self.get_dummy_components()
            _A=	PNDMScheduler(skip_prk_steps=lowerCAmelCase__       )
            torch.manual_seed(0       )
            _A=	RobertaSeriesConfig(
                hidden_size=32				,      project_dim=32				,      intermediate_size=37				,      layer_norm_eps=1E-05				,      num_attention_heads=4				,      num_hidden_layers=5				,      vocab_size=5002				,      )
            # TODO: remove after fixing the non-deterministic text encoder
            _A=	RobertaSeriesModelWithTransformation(lowerCAmelCase__       )
            _A=	text_encoder
            _A=	AltDiffusionPipeline(**lowerCAmelCase__       )
            _A=	alt_pipe.to(lowerCAmelCase__       )
            alt_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

            _A=	self.get_dummy_inputs(lowerCAmelCase__       )
            _A=	alt_pipe(**lowerCAmelCase__       )
            _A=	output.images
            _A=	image[0, -3:, -3:, -1]

            assert image.shape == (1, 64, 64, 3)
            _A=	np.array(
                [0.51605093, 0.5707241, 0.47365507, 0.50578886, 0.5633877, 0.4642503, 0.5182081, 0.48763484, 0.49084237]       )

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





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



     def 			a__  (					self       ):
            # clean up the VRAM after each test
            super().tearDown()
            gc.collect()
            torch.cuda.empty_cache()



     def 			a__  (					self       ):
            # make sure here that pndm scheduler skips prk
            _A=	AltDiffusionPipeline.from_pretrained('BAAI/AltDiffusion'				,      safety_checker=lowerCAmelCase__       )
            _A=	alt_pipe.to(lowerCAmelCase__       )
            alt_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

            _A=	'A painting of a squirrel eating a burger'
            _A=	torch.manual_seed(0       )
            _A=	alt_pipe([prompt]				,      generator=lowerCAmelCase__				,      guidance_scale=6.0				,      num_inference_steps=20				,      output_type='np'       )

            _A=	output.images

            _A=	image[0, -3:, -3:, -1]

            assert image.shape == (1, 512, 512, 3)
            _A=	np.array([0.1010, 0.0800, 0.0794, 0.0885, 0.0843, 0.0762, 0.0769, 0.0729, 0.0586]       )

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





     def 			a__  (					self       ):
            _A=	DDIMScheduler.from_pretrained('BAAI/AltDiffusion'				,      subfolder='scheduler'       )

            _A=	AltDiffusionPipeline.from_pretrained('BAAI/AltDiffusion'				,      scheduler=lowerCAmelCase__				,      safety_checker=lowerCAmelCase__       )
            _A=	alt_pipe.to(lowerCAmelCase__       )
            alt_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

            _A=	'A painting of a squirrel eating a burger'
            _A=	torch.manual_seed(0       )

            _A=	alt_pipe([prompt]				,      generator=lowerCAmelCase__				,      num_inference_steps=2				,      output_type='numpy'       )
            _A=	output.images

            _A=	image[0, -3:, -3:, -1]

            assert image.shape == (1, 512, 512, 3)
            _A=	np.array([0.4019, 0.4052, 0.3810, 0.4119, 0.3916, 0.3982, 0.4651, 0.4195, 0.5323]       )

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