


import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / """utils"""))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
   from test_module.custom_tokenization_fast import CustomTokenizerFast







class lowerCAmelCase_						(			unittest.TestCase	):

 '''simple docstring'''

 def 						UpperCamelCase__					(     self ):
       snake_case_	=				0



 @slow
 def 						UpperCamelCase__					(     self ):
       for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
             snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase )
             self.assertIsNotNone(_UpperCAmelCase )
             self.assertIsInstance(_UpperCAmelCase		,				(BertTokenizer, BertTokenizerFast) )
             self.assertGreater(len(_UpperCAmelCase )		,				0 )

       for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
             snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase )
             self.assertIsNotNone(_UpperCAmelCase )
             self.assertIsInstance(_UpperCAmelCase		,				(GPTaTokenizer, GPTaTokenizerFast) )
             self.assertGreater(len(_UpperCAmelCase )		,				0 )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase )
       self.assertIsInstance(_UpperCAmelCase		,				(BertTokenizer, BertTokenizerFast) )
       self.assertEqual(tokenizer.vocab_size		,				12 )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase )
       self.assertIsInstance(_UpperCAmelCase		,				(RobertaTokenizer, RobertaTokenizerFast) )
       self.assertEqual(tokenizer.vocab_size		,				20 )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				AutoConfig.from_pretrained(_UpperCAmelCase )
       self.assertIsInstance(_UpperCAmelCase		,				_UpperCAmelCase )
       # Check that tokenizer_type ≠ model_type
       snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase		,				config=_UpperCAmelCase )
       self.assertIsInstance(_UpperCAmelCase		,				(BertTokenizer, BertTokenizerFast) )
       self.assertEqual(tokenizer.vocab_size		,				12 )



 def 						UpperCamelCase__					(     self ):
       with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy('''./tests/fixtures/vocab.txt'''		,				os.path.join(_UpperCAmelCase		,				'''vocab.txt''' ) )

             snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase		,				tokenizer_type='''bert'''		,				use_fast=_UpperCAmelCase )
             self.assertIsInstance(_UpperCAmelCase		,				_UpperCAmelCase )

       with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy('''./tests/fixtures/vocab.json'''		,				os.path.join(_UpperCAmelCase		,				'''vocab.json''' ) )
             shutil.copy('''./tests/fixtures/merges.txt'''		,				os.path.join(_UpperCAmelCase		,				'''merges.txt''' ) )

             snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase		,				tokenizer_type='''gpt2'''		,				use_fast=_UpperCAmelCase )
             self.assertIsInstance(_UpperCAmelCase		,				_UpperCAmelCase )



 @require_tokenizers
 def 						UpperCamelCase__					(     self ):
       with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy('''./tests/fixtures/vocab.txt'''		,				os.path.join(_UpperCAmelCase		,				'''vocab.txt''' ) )

             snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase		,				tokenizer_type='''bert''' )
             self.assertIsInstance(_UpperCAmelCase		,				_UpperCAmelCase )

       with tempfile.TemporaryDirectory() as tmp_dir:
             shutil.copy('''./tests/fixtures/vocab.json'''		,				os.path.join(_UpperCAmelCase		,				'''vocab.json''' ) )
             shutil.copy('''./tests/fixtures/merges.txt'''		,				os.path.join(_UpperCAmelCase		,				'''merges.txt''' ) )

             snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase		,				tokenizer_type='''gpt2''' )
             self.assertIsInstance(_UpperCAmelCase		,				_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       with pytest.raises(_UpperCAmelCase ):
             AutoTokenizer.from_pretrained('''./'''		,				tokenizer_type='''xxx''' )



 @require_tokenizers
 def 						UpperCamelCase__					(     self ):
       for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
             snake_case_	=				tokenizer_class.from_pretrained('''wietsedv/bert-base-dutch-cased''' )
             self.assertIsInstance(_UpperCAmelCase		,				(BertTokenizer, BertTokenizerFast) )

             if isinstance(_UpperCAmelCase		,				_UpperCAmelCase ):
                   self.assertEqual(tokenizer.basic_tokenizer.do_lower_case		,				_UpperCAmelCase )
             else:
                   self.assertEqual(tokenizer.do_lower_case		,				_UpperCAmelCase )

             self.assertEqual(tokenizer.model_max_length		,				5_12 )



 @require_tokenizers
 def 						UpperCamelCase__					(     self ):
       for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
             with self.assertRaisesRegex(
                 _UpperCAmelCase		,				'''julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier'''		,				):
                   snake_case_	=				tokenizer_class.from_pretrained('''julien-c/herlolip-not-exists''' )



 def 						UpperCamelCase__					(     self ):
       # tests: https://github.com/huggingface/transformers/pull/13251
       # 1. models with `-`, e.g. xlm-roberta -> xlm_roberta
       # 2. models that don't remap 1-1 from model-name to model file, e.g., openai-gpt -> openai
       snake_case_	=				TOKENIZER_MAPPING.values()
       snake_case_	=				[]

       for slow_tok, fast_tok in tokenizers:
             if slow_tok is not None:
                   tokenizer_names.append(slow_tok.__name__ )

             if fast_tok is not None:
                   tokenizer_names.append(fast_tok.__name__ )

       for tokenizer_name in tokenizer_names:
             # must find the right class
             tokenizer_class_from_name(_UpperCAmelCase )



 @require_tokenizers
 def 						UpperCamelCase__					(     self ):
       self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased'''		,				use_fast=_UpperCAmelCase )		,				_UpperCAmelCase )
       self.assertIsInstance(AutoTokenizer.from_pretrained('''bert-base-cased''' )		,				_UpperCAmelCase )



 @require_tokenizers
 def 						UpperCamelCase__					(     self ):
       snake_case_	=				AutoTokenizer.from_pretrained('''distilbert-base-uncased'''		,				do_lower_case=_UpperCAmelCase )
       snake_case_	=				'''Hello, world. How are you?'''
       snake_case_	=				tokenizer.tokenize(_UpperCAmelCase )
       self.assertEqual('''[UNK]'''		,				tokens[0] )

       snake_case_	=				AutoTokenizer.from_pretrained('''microsoft/mpnet-base'''		,				do_lower_case=_UpperCAmelCase )
       snake_case_	=				tokenizer.tokenize(_UpperCAmelCase )
       self.assertEqual('''[UNK]'''		,				tokens[0] )



 @require_tokenizers
 def 						UpperCamelCase__					(     self ):
       snake_case_	=				AutoTokenizer.from_pretrained('''robot-test/dummy-tokenizer-fast-with-model-config''' )
       self.assertEqual(type(_UpperCAmelCase )		,				_UpperCAmelCase )
       self.assertEqual(tokenizer.model_max_length		,				5_12 )
       self.assertEqual(tokenizer.vocab_size		,				3_00_00 )
       self.assertEqual(tokenizer.unk_token		,				'''[UNK]''' )
       self.assertEqual(tokenizer.padding_side		,				'''right''' )
       self.assertEqual(tokenizer.truncation_side		,				'''right''' )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase )
       self.assertIsInstance(_UpperCAmelCase		,				(BertTokenizer, BertTokenizerFast) )
       with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(_UpperCAmelCase )
             snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase )

       self.assertIsInstance(_UpperCAmelCase		,				tokenizer.__class__ )
       self.assertEqual(tokenizera.vocab_size		,				12 )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				AutoTokenizer.from_pretrained('''ctrl''' )
       # There is no fast CTRL so this always gives us a slow tokenizer.
       self.assertIsInstance(_UpperCAmelCase		,				_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       # Check we can load the tokenizer config of an online model.
       snake_case_	=				get_tokenizer_config('''bert-base-cased''' )
       snake_case_	=				config.pop('''_commit_hash'''		,				_UpperCAmelCase )
       # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
       self.assertEqual(_UpperCAmelCase		,				{'''do_lower_case''': False} )

       # This model does not have a tokenizer_config so we get back an empty dict.
       snake_case_	=				get_tokenizer_config(_UpperCAmelCase )
       self.assertDictEqual(_UpperCAmelCase		,				{} )

       # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
       snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase )
       with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(_UpperCAmelCase )
             snake_case_	=				get_tokenizer_config(_UpperCAmelCase )

       # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
       self.assertEqual(config['''tokenizer_class''']		,				'''BertTokenizer''' )



 def 						UpperCamelCase__					(     self ):
       try:
             AutoConfig.register('''custom'''		,				_UpperCAmelCase )

             AutoTokenizer.register(_UpperCAmelCase		,				slow_tokenizer_class=_UpperCAmelCase )
             # Trying to register something existing in the Transformers library will raise an error
             with self.assertRaises(_UpperCAmelCase ):
                   AutoTokenizer.register(_UpperCAmelCase		,				slow_tokenizer_class=_UpperCAmelCase )

             snake_case_	=				CustomTokenizer.from_pretrained(_UpperCAmelCase )
             with tempfile.TemporaryDirectory() as tmp_dir:
                   tokenizer.save_pretrained(_UpperCAmelCase )

                   snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase )
                   self.assertIsInstance(_UpperCAmelCase		,				_UpperCAmelCase )

       finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                   del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                   del TOKENIZER_MAPPING._extra_content[CustomConfig]



 @require_tokenizers
 def 						UpperCamelCase__					(     self ):
       try:
             AutoConfig.register('''custom'''		,				_UpperCAmelCase )

             # Can register in two steps
             AutoTokenizer.register(_UpperCAmelCase		,				slow_tokenizer_class=_UpperCAmelCase )
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,				(CustomTokenizer, None) )
             AutoTokenizer.register(_UpperCAmelCase		,				fast_tokenizer_class=_UpperCAmelCase )
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,				(CustomTokenizer, CustomTokenizerFast) )

             del TOKENIZER_MAPPING._extra_content[CustomConfig]
             # Can register in one step
             AutoTokenizer.register(
                 _UpperCAmelCase		,				slow_tokenizer_class=_UpperCAmelCase		,				fast_tokenizer_class=_UpperCAmelCase )
             self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,				(CustomTokenizer, CustomTokenizerFast) )

             # Trying to register something existing in the Transformers library will raise an error
             with self.assertRaises(_UpperCAmelCase ):
                   AutoTokenizer.register(_UpperCAmelCase		,				fast_tokenizer_class=_UpperCAmelCase )

             # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
             # and that model does not have a tokenizer.json
             with tempfile.TemporaryDirectory() as tmp_dir:
                   snake_case_	=				BertTokenizerFast.from_pretrained(_UpperCAmelCase )
                   bert_tokenizer.save_pretrained(_UpperCAmelCase )
                   snake_case_	=				CustomTokenizerFast.from_pretrained(_UpperCAmelCase )

             with tempfile.TemporaryDirectory() as tmp_dir:
                   tokenizer.save_pretrained(_UpperCAmelCase )

                   snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase )
                   self.assertIsInstance(_UpperCAmelCase		,				_UpperCAmelCase )

                   snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase		,				use_fast=_UpperCAmelCase )
                   self.assertIsInstance(_UpperCAmelCase		,				_UpperCAmelCase )

       finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                   del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                   del TOKENIZER_MAPPING._extra_content[CustomConfig]



 def 						UpperCamelCase__					(     self ):
       # If remote code is not set, we will time out when asking whether to load the model.
       with self.assertRaises(_UpperCAmelCase ):
             snake_case_	=				AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer''' )
       # If remote code is disabled, we can't load this config.
       with self.assertRaises(_UpperCAmelCase ):
             snake_case_	=				AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=_UpperCAmelCase )

       snake_case_	=				AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=_UpperCAmelCase )
       self.assertTrue(tokenizer.special_attribute_present )
       # Test tokenizer can be reloaded.
       with tempfile.TemporaryDirectory() as tmp_dir:
             tokenizer.save_pretrained(_UpperCAmelCase )
             snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase		,				trust_remote_code=_UpperCAmelCase )
       self.assertTrue(reloaded_tokenizer.special_attribute_present )

       if is_tokenizers_available():
             self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizerFast''' )
             self.assertEqual(reloaded_tokenizer.__class__.__name__		,				'''NewTokenizerFast''' )

             # Test we can also load the slow version
             snake_case_	=				AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=_UpperCAmelCase		,				use_fast=_UpperCAmelCase )
             self.assertTrue(tokenizer.special_attribute_present )
             self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer''' )
             # Test tokenizer can be reloaded.
             with tempfile.TemporaryDirectory() as tmp_dir:
                   tokenizer.save_pretrained(_UpperCAmelCase )
                   snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase		,				trust_remote_code=_UpperCAmelCase		,				use_fast=_UpperCAmelCase )
             self.assertEqual(reloaded_tokenizer.__class__.__name__		,				'''NewTokenizer''' )
             self.assertTrue(reloaded_tokenizer.special_attribute_present )
       else:
             self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer''' )
             self.assertEqual(reloaded_tokenizer.__class__.__name__		,				'''NewTokenizer''' )



 @require_tokenizers
 def 						UpperCamelCase__					(     self ):







       class lowerCAmelCase_						(			lowerCamelCase__	):

        '''simple docstring'''

        __snake_case												=  False







       class lowerCAmelCase_						(			lowerCamelCase__	):

        '''simple docstring'''

        __snake_case												=  NewTokenizer
        __snake_case												=  False

       try:
             AutoConfig.register('''custom'''		,				_UpperCAmelCase )
             AutoTokenizer.register(_UpperCAmelCase		,				slow_tokenizer_class=_UpperCAmelCase )
             AutoTokenizer.register(_UpperCAmelCase		,				fast_tokenizer_class=_UpperCAmelCase )
             # If remote code is not set, the default is to use local
             snake_case_	=				AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer''' )
             self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizerFast''' )
             self.assertFalse(tokenizer.special_attribute_present )
             snake_case_	=				AutoTokenizer.from_pretrained('''hf-internal-testing/test_dynamic_tokenizer'''		,				use_fast=_UpperCAmelCase )
             self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer''' )
             self.assertFalse(tokenizer.special_attribute_present )

             # If remote code is disabled, we load the local one.
             snake_case_	=				AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=_UpperCAmelCase )
             self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizerFast''' )
             self.assertFalse(tokenizer.special_attribute_present )
             snake_case_	=				AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=_UpperCAmelCase		,				use_fast=_UpperCAmelCase )
             self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer''' )
             self.assertFalse(tokenizer.special_attribute_present )

             # If remote is enabled, we load from the Hub
             snake_case_	=				AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=_UpperCAmelCase )
             self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizerFast''' )
             self.assertTrue(tokenizer.special_attribute_present )
             snake_case_	=				AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer'''		,				trust_remote_code=_UpperCAmelCase		,				use_fast=_UpperCAmelCase )
             self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer''' )
             self.assertTrue(tokenizer.special_attribute_present )

       finally:
             if "custom" in CONFIG_MAPPING._extra_content:
                   del CONFIG_MAPPING._extra_content["custom"]
             if CustomConfig in TOKENIZER_MAPPING._extra_content:
                   del TOKENIZER_MAPPING._extra_content[CustomConfig]



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				AutoTokenizer.from_pretrained(
           '''hf-internal-testing/test_dynamic_tokenizer_legacy'''		,				trust_remote_code=_UpperCAmelCase )
       self.assertTrue(tokenizer.special_attribute_present )
       if is_tokenizers_available():
             self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizerFast''' )

             # Test we can also load the slow version
             snake_case_	=				AutoTokenizer.from_pretrained(
                 '''hf-internal-testing/test_dynamic_tokenizer_legacy'''		,				trust_remote_code=_UpperCAmelCase		,				use_fast=_UpperCAmelCase )
             self.assertTrue(tokenizer.special_attribute_present )
             self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer''' )
       else:
             self.assertEqual(tokenizer.__class__.__name__		,				'''NewTokenizer''' )



 def 						UpperCamelCase__					(     self ):
       with self.assertRaisesRegex(
           _UpperCAmelCase		,				'''bert-base is not a local folder and is not a valid model identifier''' ):
             snake_case_	=				AutoTokenizer.from_pretrained('''bert-base''' )



 def 						UpperCamelCase__					(     self ):
       with self.assertRaisesRegex(
           _UpperCAmelCase		,				R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)''' ):
             snake_case_	=				AutoTokenizer.from_pretrained(_UpperCAmelCase		,				revision='''aaaaaa''' )





 def 						UpperCamelCase__					(     self ):
       # Make sure we have cached the tokenizer.
       snake_case_	=				AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert''' )
       with RequestCounter() as counter:
             snake_case_	=				AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert''' )
             self.assertEqual(counter.get_request_count		,				0 )
             self.assertEqual(counter.head_request_count		,				1 )
             self.assertEqual(counter.other_request_count		,				0 )



import gc
import unittest

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

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


UpperCAmelCase      =   False







class lowerCAmelCase_						(			unittest.TestCase	):

 '''simple docstring'''

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



 @property
 def 						UpperCamelCase__					(     self ):
       return 12



 @property
 def 						UpperCamelCase__					(     self ):
       return 12



 @property
 def 						UpperCamelCase__					(     self ):
       return 32



 @property
 def 						UpperCamelCase__					(     self ):
       torch.manual_seed(0 )
       snake_case_	=				VQModel(
           block_out_channels=[32, 64]		,				in_channels=3		,				out_channels=3		,				down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']		,				up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']		,				latent_channels=3		,				num_vq_embeddings=self.num_embed		,				vq_embed_dim=3		,				)
       return model



 @property
 def 						UpperCamelCase__					(     self ):
       snake_case_	=				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip''' )
       return tokenizer



 @property
 def 						UpperCamelCase__					(     self ):
       torch.manual_seed(0 )
       snake_case_	=				CLIPTextConfig(
           bos_token_id=0		,				eos_token_id=2		,				hidden_size=self.text_embedder_hidden_size		,				intermediate_size=37		,				layer_norm_eps=1E-05		,				num_attention_heads=4		,				num_hidden_layers=5		,				pad_token_id=1		,				vocab_size=10_00		,				)
       return CLIPTextModel(_UpperCAmelCase )



 @property
 def 						UpperCamelCase__					(     self ):
       torch.manual_seed(0 )

       snake_case_	=				12
       snake_case_	=				12

       snake_case_	=				{
           '''attention_bias''': True,
           '''cross_attention_dim''': 32,
           '''attention_head_dim''': height * width,
           '''num_attention_heads''': 1,
           '''num_vector_embeds''': self.num_embed,
           '''num_embeds_ada_norm''': self.num_embeds_ada_norm,
           '''norm_num_groups''': 32,
           '''sample_size''': width,
           '''activation_fn''': '''geglu-approximate''',
       }

       snake_case_	=				TransformeraDModel(**_UpperCAmelCase )
       return model



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				'''cpu'''

       snake_case_	=				self.dummy_vqvae
       snake_case_	=				self.dummy_text_encoder
       snake_case_	=				self.dummy_tokenizer
       snake_case_	=				self.dummy_transformer
       snake_case_	=				VQDiffusionScheduler(self.num_embed )
       snake_case_	=				LearnedClassifierFreeSamplingEmbeddings(learnable=_UpperCAmelCase )

       snake_case_	=				VQDiffusionPipeline(
           vqvae=_UpperCAmelCase		,				text_encoder=_UpperCAmelCase		,				tokenizer=_UpperCAmelCase		,				transformer=_UpperCAmelCase		,				scheduler=_UpperCAmelCase		,				learned_classifier_free_sampling_embeddings=_UpperCAmelCase		,				)
       snake_case_	=				pipe.to(_UpperCAmelCase )
       pipe.set_progress_bar_config(disable=_UpperCAmelCase )

       snake_case_	=				'''teddy bear playing in the pool'''

       snake_case_	=				torch.Generator(device=_UpperCAmelCase ).manual_seed(0 )
       snake_case_	=				pipe([prompt]		,				generator=_UpperCAmelCase		,				num_inference_steps=2		,				output_type='''np''' )
       snake_case_	=				output.images

       snake_case_	=				torch.Generator(device=_UpperCAmelCase ).manual_seed(0 )
       snake_case_	=				pipe(
           [prompt]		,				generator=_UpperCAmelCase		,				output_type='''np'''		,				return_dict=_UpperCAmelCase		,				num_inference_steps=2 )[0]

       snake_case_	=				image[0, -3:, -3:, -1]
       snake_case_	=				image_from_tuple[0, -3:, -3:, -1]

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

       snake_case_	=				np.array([0.6_551, 0.6_168, 0.5_008, 0.5_676, 0.5_659, 0.4_295, 0.6_073, 0.5_599, 0.4_992] )

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





 def 						UpperCamelCase__					(     self ):
       snake_case_	=				'''cpu'''

       snake_case_	=				self.dummy_vqvae
       snake_case_	=				self.dummy_text_encoder
       snake_case_	=				self.dummy_tokenizer
       snake_case_	=				self.dummy_transformer
       snake_case_	=				VQDiffusionScheduler(self.num_embed )
       snake_case_	=				LearnedClassifierFreeSamplingEmbeddings(
           learnable=_UpperCAmelCase		,				hidden_size=self.text_embedder_hidden_size		,				length=tokenizer.model_max_length )

       snake_case_	=				VQDiffusionPipeline(
           vqvae=_UpperCAmelCase		,				text_encoder=_UpperCAmelCase		,				tokenizer=_UpperCAmelCase		,				transformer=_UpperCAmelCase		,				scheduler=_UpperCAmelCase		,				learned_classifier_free_sampling_embeddings=_UpperCAmelCase		,				)
       snake_case_	=				pipe.to(_UpperCAmelCase )
       pipe.set_progress_bar_config(disable=_UpperCAmelCase )

       snake_case_	=				'''teddy bear playing in the pool'''

       snake_case_	=				torch.Generator(device=_UpperCAmelCase ).manual_seed(0 )
       snake_case_	=				pipe([prompt]		,				generator=_UpperCAmelCase		,				num_inference_steps=2		,				output_type='''np''' )
       snake_case_	=				output.images

       snake_case_	=				torch.Generator(device=_UpperCAmelCase ).manual_seed(0 )
       snake_case_	=				pipe(
           [prompt]		,				generator=_UpperCAmelCase		,				output_type='''np'''		,				return_dict=_UpperCAmelCase		,				num_inference_steps=2 )[0]

       snake_case_	=				image[0, -3:, -3:, -1]
       snake_case_	=				image_from_tuple[0, -3:, -3:, -1]

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

       snake_case_	=				np.array([0.6_693, 0.6_075, 0.4_959, 0.5_701, 0.5_583, 0.4_333, 0.6_171, 0.5_684, 0.4_988] )

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







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

 '''simple docstring'''

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





 def 						UpperCamelCase__					(     self ):
       snake_case_	=				load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
           '''/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy''' )

       snake_case_	=				VQDiffusionPipeline.from_pretrained('''microsoft/vq-diffusion-ithq''' )
       snake_case_	=				pipeline.to(_UpperCAmelCase )
       pipeline.set_progress_bar_config(disable=_UpperCAmelCase )

       # requires GPU generator for gumbel softmax
       # don't use GPU generator in tests though
       snake_case_	=				torch.Generator(device=_UpperCAmelCase ).manual_seed(0 )
       snake_case_	=				pipeline(
           '''teddy bear playing in the pool'''		,				num_images_per_prompt=1		,				generator=_UpperCAmelCase		,				output_type='''np'''		,				)

       snake_case_	=				output.images[0]

       assert image.shape == (2_56, 2_56, 3)
       assert np.abs(expected_image - image ).max() < 2.0