
"""simple docstring"""




import os
import unittest

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    BertTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english





@require_tokenizers
class  snake_case     (							__lowercase       ,			unittest.TestCase   ):
							UpperCAmelCase__						     =      BertTokenizer
							UpperCAmelCase__						     =      BertTokenizerFast
							UpperCAmelCase__						     =      True
							UpperCAmelCase__						     =      True
							UpperCAmelCase__						     =      filter_non_english

							def _lowercase					(self    ):

									"""simple docstring"""







									super().setUp()

									SCREAMING_SNAKE_CASE_						 = [
									    '''[UNK]''',
									    '''[CLS]''',
									    '''[SEP]''',
									    '''[PAD]''',
									    '''[MASK]''',
									    '''want''',
									    '''##want''',
									    '''##ed''',
									    '''wa''',
									    '''un''',
									    '''runn''',
									    '''##ing''',
									    ''',''',
									    '''low''',
									    '''lowest''',
									]
									SCREAMING_SNAKE_CASE_						 = os.path.join(self.tmpdirname       ,       VOCAB_FILES_NAMES['''vocab_file''']    )
									with open(self.vocab_file       ,       '''w'''       ,       encoding='''utf-8'''    ) as vocab_writer:
											vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]    )    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = '''UNwant\u00E9d,running'''
									SCREAMING_SNAKE_CASE_						 = '''unwanted, running'''
									return input_text, output_text

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.tokenizer_class(self.vocab_file    )

									SCREAMING_SNAKE_CASE_						 = tokenizer.tokenize('''UNwant\u00E9d,running'''    )
									self.assertListEqual(SCREAMING_SNAKE_CASE_       ,       ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']    )
									self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_    )       ,       [9, 6, 7, 12, 10, 11]    )

							def _lowercase					(self    ):

									"""simple docstring"""







									if not self.test_rust_tokenizer:
											return

									SCREAMING_SNAKE_CASE_						 = self.get_tokenizer()
									SCREAMING_SNAKE_CASE_						 = self.get_rust_tokenizer()

									SCREAMING_SNAKE_CASE_						 = '''UNwant\u00E9d,running'''

									SCREAMING_SNAKE_CASE_						 = tokenizer.tokenize(SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_    )
									self.assertListEqual(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = tokenizer.encode(SCREAMING_SNAKE_CASE_       ,       add_special_tokens=SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = rust_tokenizer.encode(SCREAMING_SNAKE_CASE_       ,       add_special_tokens=SCREAMING_SNAKE_CASE_    )
									self.assertListEqual(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = self.get_rust_tokenizer()
									SCREAMING_SNAKE_CASE_						 = tokenizer.encode(SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = rust_tokenizer.encode(SCREAMING_SNAKE_CASE_    )
									self.assertListEqual(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

									# With lower casing
									SCREAMING_SNAKE_CASE_						 = self.get_tokenizer(do_lower_case=SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = self.get_rust_tokenizer(do_lower_case=SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = '''UNwant\u00E9d,running'''

									SCREAMING_SNAKE_CASE_						 = tokenizer.tokenize(SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_    )
									self.assertListEqual(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = tokenizer.encode(SCREAMING_SNAKE_CASE_       ,       add_special_tokens=SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = rust_tokenizer.encode(SCREAMING_SNAKE_CASE_       ,       add_special_tokens=SCREAMING_SNAKE_CASE_    )
									self.assertListEqual(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = self.get_rust_tokenizer()
									SCREAMING_SNAKE_CASE_						 = tokenizer.encode(SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = rust_tokenizer.encode(SCREAMING_SNAKE_CASE_    )
									self.assertListEqual(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = BasicTokenizer()

									self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz'''    )       ,       ['''ah''', '''\u535A''', '''\u63A8''', '''zz''']    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_    )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''    )       ,       ['''hello''', '''!''', '''how''', '''are''', '''you''', '''?''']    )
									self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''    )       ,       ['''hello''']    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_       ,       strip_accents=SCREAMING_SNAKE_CASE_    )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''    )       ,       ['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?''']    )
									self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''    )       ,       ['''h\u00E9llo''']    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_       ,       strip_accents=SCREAMING_SNAKE_CASE_    )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''    )       ,       ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']    )
									self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''    )       ,       ['''hello''']    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_    )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''    )       ,       ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']    )
									self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''    )       ,       ['''hello''']    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_    )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''    )       ,       ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_       ,       strip_accents=SCREAMING_SNAKE_CASE_    )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''    )       ,       ['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_       ,       strip_accents=SCREAMING_SNAKE_CASE_    )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''    )       ,       ['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_       ,       never_split=['''[UNK]''']    )

									self.assertListEqual(
									    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]'''    )       ,       ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]''']    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = BasicTokenizer()
									SCREAMING_SNAKE_CASE_						 = '''a\n\'ll !!to?\'d of, can\'t.'''
									SCREAMING_SNAKE_CASE_						 = ['''a''', '''\'''', '''ll''', '''!''', '''!''', '''to''', '''?''', '''\'''', '''d''', '''of''', ''',''', '''can''', '''\'''', '''t''', '''.''']
									self.assertListEqual(tokenizer.tokenize(SCREAMING_SNAKE_CASE_    )       ,       SCREAMING_SNAKE_CASE_    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

									SCREAMING_SNAKE_CASE_						 = {}
									for i, token in enumerate(SCREAMING_SNAKE_CASE_    ):
											SCREAMING_SNAKE_CASE_						 = i
									SCREAMING_SNAKE_CASE_						 = WordpieceTokenizer(vocab=SCREAMING_SNAKE_CASE_       ,       unk_token='''[UNK]'''    )

									self.assertListEqual(tokenizer.tokenize(''''''    )       ,       []    )

									self.assertListEqual(tokenizer.tokenize('''unwanted running'''    )       ,       ['''un''', '''##want''', '''##ed''', '''runn''', '''##ing''']    )

									self.assertListEqual(tokenizer.tokenize('''unwantedX running'''    )       ,       ['''[UNK]''', '''runn''', '''##ing''']    )

							def _lowercase					(self    ):

									"""simple docstring"""







									self.assertTrue(_is_whitespace(''' '''    )    )
									self.assertTrue(_is_whitespace('''\t'''    )    )
									self.assertTrue(_is_whitespace('''\r'''    )    )
									self.assertTrue(_is_whitespace('''\n'''    )    )
									self.assertTrue(_is_whitespace('''\u00A0'''    )    )

									self.assertFalse(_is_whitespace('''A'''    )    )
									self.assertFalse(_is_whitespace('''-'''    )    )

							def _lowercase					(self    ):

									"""simple docstring"""







									self.assertTrue(_is_control('''\u0005'''    )    )

									self.assertFalse(_is_control('''A'''    )    )
									self.assertFalse(_is_control(''' '''    )    )
									self.assertFalse(_is_control('''\t'''    )    )
									self.assertFalse(_is_control('''\r'''    )    )

							def _lowercase					(self    ):

									"""simple docstring"""







									self.assertTrue(_is_punctuation('''-'''    )    )
									self.assertTrue(_is_punctuation('''$'''    )    )
									self.assertTrue(_is_punctuation('''`'''    )    )
									self.assertTrue(_is_punctuation('''.'''    )    )

									self.assertFalse(_is_punctuation('''A'''    )    )
									self.assertFalse(_is_punctuation(''' '''    )    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.get_tokenizer()
									SCREAMING_SNAKE_CASE_						 = self.get_rust_tokenizer()

									# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
									self.assertListEqual([tokenizer.tokenize(SCREAMING_SNAKE_CASE_    ) for t in ['''Test''', '''\xad''', '''test''']]       ,       [['''[UNK]'''], [], ['''[UNK]''']]    )

									self.assertListEqual(
									    [rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_    ) for t in ['''Test''', '''\xad''', '''test''']]       ,       [['''[UNK]'''], [], ['''[UNK]''']]    )

							@slow
							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.tokenizer_class.from_pretrained('''bert-base-uncased'''    )

									SCREAMING_SNAKE_CASE_						 = tokenizer.encode('''sequence builders'''       ,       add_special_tokens=SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = tokenizer.encode('''multi-sequence build'''       ,       add_special_tokens=SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

									assert encoded_sentence == [1_01] + text + [1_02]
									assert encoded_pair == [1_01] + text + [1_02] + text_a + [1_02]

							def _lowercase					(self    ):

									"""simple docstring"""







									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'    ):
													SCREAMING_SNAKE_CASE_						 = self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_       ,       **SCREAMING_SNAKE_CASE_    )

													SCREAMING_SNAKE_CASE_						 = f'A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'
													SCREAMING_SNAKE_CASE_						 = tokenizer_r.encode_plus(
													    SCREAMING_SNAKE_CASE_       ,       return_attention_mask=SCREAMING_SNAKE_CASE_       ,       return_token_type_ids=SCREAMING_SNAKE_CASE_       ,       return_offsets_mapping=SCREAMING_SNAKE_CASE_       ,       add_special_tokens=SCREAMING_SNAKE_CASE_       ,       )

													SCREAMING_SNAKE_CASE_						 = tokenizer_r.do_lower_case if hasattr(SCREAMING_SNAKE_CASE_       ,       '''do_lower_case'''    ) else False
													SCREAMING_SNAKE_CASE_						 = (
													    [
													        ((0, 0), tokenizer_r.cls_token),
													        ((0, 1), '''A'''),
													        ((1, 2), ''','''),
													        ((3, 5), '''na'''),
													        ((5, 6), '''##ï'''),
													        ((6, 8), '''##ve'''),
													        ((9, 15), tokenizer_r.mask_token),
													        ((16, 21), '''Allen'''),
													        ((21, 23), '''##NL'''),
													        ((23, 24), '''##P'''),
													        ((25, 33), '''sentence'''),
													        ((33, 34), '''.'''),
													        ((0, 0), tokenizer_r.sep_token),
													    ]
													    if not do_lower_case
													    else [
													        ((0, 0), tokenizer_r.cls_token),
													        ((0, 1), '''a'''),
													        ((1, 2), ''','''),
													        ((3, 8), '''naive'''),
													        ((9, 15), tokenizer_r.mask_token),
													        ((16, 21), '''allen'''),
													        ((21, 23), '''##nl'''),
													        ((23, 24), '''##p'''),
													        ((25, 33), '''sentence'''),
													        ((33, 34), '''.'''),
													        ((0, 0), tokenizer_r.sep_token),
													    ]
													)

													self.assertEqual(
													    [e[1] for e in expected_results]       ,       tokenizer_r.convert_ids_to_tokens(tokens['''input_ids''']    )    )
													self.assertEqual([e[0] for e in expected_results]       ,       tokens['''offset_mapping''']    )







							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = ['''的''', '''人''', '''有''']
									SCREAMING_SNAKE_CASE_						 = ''''''.join(SCREAMING_SNAKE_CASE_    )
									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'    ):
													SCREAMING_SNAKE_CASE_						 = True
													SCREAMING_SNAKE_CASE_						 = self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_       ,       **SCREAMING_SNAKE_CASE_    )
													SCREAMING_SNAKE_CASE_						 = self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_       ,       **SCREAMING_SNAKE_CASE_    )

													SCREAMING_SNAKE_CASE_						 = tokenizer_p.encode(SCREAMING_SNAKE_CASE_       ,       add_special_tokens=SCREAMING_SNAKE_CASE_    )
													SCREAMING_SNAKE_CASE_						 = tokenizer_r.encode(SCREAMING_SNAKE_CASE_       ,       add_special_tokens=SCREAMING_SNAKE_CASE_    )

													SCREAMING_SNAKE_CASE_						 = tokenizer_r.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_    )
													SCREAMING_SNAKE_CASE_						 = tokenizer_p.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_    )

													# it is expected that each Chinese character is not preceded by "##"
													self.assertListEqual(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )
													self.assertListEqual(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

													SCREAMING_SNAKE_CASE_						 = False
													SCREAMING_SNAKE_CASE_						 = self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_       ,       **SCREAMING_SNAKE_CASE_    )
													SCREAMING_SNAKE_CASE_						 = self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_       ,       **SCREAMING_SNAKE_CASE_    )

													SCREAMING_SNAKE_CASE_						 = tokenizer_r.encode(SCREAMING_SNAKE_CASE_       ,       add_special_tokens=SCREAMING_SNAKE_CASE_    )
													SCREAMING_SNAKE_CASE_						 = tokenizer_p.encode(SCREAMING_SNAKE_CASE_       ,       add_special_tokens=SCREAMING_SNAKE_CASE_    )

													SCREAMING_SNAKE_CASE_						 = tokenizer_r.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_    )
													SCREAMING_SNAKE_CASE_						 = tokenizer_p.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_    )

													# it is expected that only the first Chinese character is not preceded by "##".
													SCREAMING_SNAKE_CASE_						 = [
													    f'##{token}' if idx != 0 else token for idx, token in enumerate(SCREAMING_SNAKE_CASE_    )
													]
													self.assertListEqual(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )
													self.assertListEqual(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    )

"""simple docstring"""




import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


lowerCAmelCase__							=				False





class  snake_case     (							unittest.TestCase   ):
							pass







@nightly
@require_torch_gpu
class  snake_case     (							unittest.TestCase   ):

							def _lowercase					(self    ):

									"""simple docstring"""







									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = VersatileDiffusionPipeline.from_pretrained('''shi-labs/versatile-diffusion'''       ,       torch_dtype=torch.floataa    )
									pipe.to(SCREAMING_SNAKE_CASE_    )
									pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = load_image(
									    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''    )

									SCREAMING_SNAKE_CASE_						 = torch.manual_seed(0    )
									SCREAMING_SNAKE_CASE_						 = pipe.dual_guided(
									    prompt='''first prompt'''       ,       image=SCREAMING_SNAKE_CASE_       ,       text_to_image_strength=0.75       ,       generator=SCREAMING_SNAKE_CASE_       ,       guidance_scale=7.5       ,       num_inference_steps=2       ,       output_type='''numpy'''       ,       ).images

									with tempfile.TemporaryDirectory() as tmpdirname:
											pipe.save_pretrained(SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = VersatileDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE_       ,       torch_dtype=torch.floataa    )
									pipe.to(SCREAMING_SNAKE_CASE_    )
									pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = generator.manual_seed(0    )
									SCREAMING_SNAKE_CASE_						 = pipe.dual_guided(
									    prompt='''first prompt'''       ,       image=SCREAMING_SNAKE_CASE_       ,       text_to_image_strength=0.75       ,       generator=SCREAMING_SNAKE_CASE_       ,       guidance_scale=7.5       ,       num_inference_steps=2       ,       output_type='''numpy'''       ,       ).images

									assert np.abs(image - new_image    ).sum() < 1e-5, "Models don't have the same forward pass"







							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = VersatileDiffusionPipeline.from_pretrained('''shi-labs/versatile-diffusion'''       ,       torch_dtype=torch.floataa    )
									pipe.to(SCREAMING_SNAKE_CASE_    )
									pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_    )

									SCREAMING_SNAKE_CASE_						 = '''cyberpunk 2077'''
									SCREAMING_SNAKE_CASE_						 = load_image(
									    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''    )
									SCREAMING_SNAKE_CASE_						 = torch.manual_seed(0    )
									SCREAMING_SNAKE_CASE_						 = pipe.dual_guided(
									    prompt=SCREAMING_SNAKE_CASE_       ,       image=SCREAMING_SNAKE_CASE_       ,       text_to_image_strength=0.75       ,       generator=SCREAMING_SNAKE_CASE_       ,       guidance_scale=7.5       ,       num_inference_steps=50       ,       output_type='''numpy'''       ,       ).images

									SCREAMING_SNAKE_CASE_						 = image[0, 2_53:2_56, 2_53:2_56, -1]

									assert image.shape == (1, 5_12, 5_12, 3)
									SCREAMING_SNAKE_CASE_						 = np.array([0.14_48, 0.16_19, 0.17_41, 0.10_86, 0.11_47, 0.11_28, 0.11_99, 0.11_65, 0.10_01]    )

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

									SCREAMING_SNAKE_CASE_						 = '''A painting of a squirrel eating a burger '''
									SCREAMING_SNAKE_CASE_						 = torch.manual_seed(0    )
									SCREAMING_SNAKE_CASE_						 = pipe.text_to_image(
									    prompt=SCREAMING_SNAKE_CASE_       ,       generator=SCREAMING_SNAKE_CASE_       ,       guidance_scale=7.5       ,       num_inference_steps=50       ,       output_type='''numpy'''    ).images

									SCREAMING_SNAKE_CASE_						 = image[0, 2_53:2_56, 2_53:2_56, -1]

									assert image.shape == (1, 5_12, 5_12, 3)
									SCREAMING_SNAKE_CASE_						 = np.array([0.33_67, 0.31_69, 0.26_56, 0.38_70, 0.47_90, 0.37_96, 0.40_09, 0.48_78, 0.47_78]    )

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

									SCREAMING_SNAKE_CASE_						 = pipe.image_variation(SCREAMING_SNAKE_CASE_       ,       generator=SCREAMING_SNAKE_CASE_       ,       output_type='''numpy'''    ).images

									SCREAMING_SNAKE_CASE_						 = image[0, 2_53:2_56, 2_53:2_56, -1]

									assert image.shape == (1, 5_12, 5_12, 3)
									SCREAMING_SNAKE_CASE_						 = np.array([0.30_76, 0.31_23, 0.32_84, 0.37_82, 0.37_70, 0.38_94, 0.42_97, 0.43_31, 0.44_56]    )

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