code: 
  
  
  import random
  import unittest
  
  import numpy as np
  import torch
  from PIL import Image
  from torch import nn
  from transformers import (
      CLIPImageProcessor,
      CLIPTextConfig,
      CLIPTextModelWithProjection,
      CLIPTokenizer,
      CLIPVisionConfig,
      CLIPVisionModelWithProjection,
  )
  
  from diffusers import KandinskyVaaPriorEmbaEmbPipeline, PriorTransformer, UnCLIPScheduler
  from diffusers.utils import floats_tensor, torch_device
  from diffusers.utils.testing_utils import enable_full_determinism, skip_mps
  
  from ..test_pipelines_common import PipelineTesterMixin
  
  
  enable_full_determinism()
  
  
  
  
  
  
  class 				__SCREAMING_SNAKE_CASE   (			A__  ,						unittest.TestCase   ):
        A				:							Union[str, Any]    							=     KandinskyVaaPriorEmbaEmbPipeline
        A				:							Optional[Any]    							=     ['prompt', 'image']
        A				:							List[Any]    							=     ['prompt', 'image']
        A				:							int    							=     [
            'num_images_per_prompt',
            'strength',
            'generator',
            'num_inference_steps',
            'latents',
            'negative_prompt',
            'guidance_scale',
            'output_type',
            'return_dict',
        ]
        A				:							Optional[int]    							=     False
  
  
        @property
        def        __lowerCamelCase			(							self		):
              return 32
  
  
        @property
        def        __lowerCamelCase			(							self		):
              return 32
  
  
        @property
        def        __lowerCamelCase			(							self		):
              return self.time_input_dim
  
  
        @property
        def        __lowerCamelCase			(							self		):
              return self.time_input_dim * 4
  
  
        @property
        def        __lowerCamelCase			(							self		):
              return 100
  
  
        @property
        def        __lowerCamelCase			(							self		):
              lowercase			:   Tuple					   =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)
              return tokenizer
  
  
        @property
        def        __lowerCamelCase			(							self		):
              torch.manual_seed(0		)
              lowercase			:   List[str]					   =		CLIPTextConfig(
                  bos_token_id=0							,						eos_token_id=2							,						hidden_size=self.text_embedder_hidden_size							,						projection_dim=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=1000							,						)
              return CLIPTextModelWithProjection(SCREAMING_SNAKE_CASE__		)
  
  
        @property
        def        __lowerCamelCase			(							self		):
              torch.manual_seed(0		)
  
              lowercase			:   Optional[Any]					   =		{
                  '''num_attention_heads''': 2,
                  '''attention_head_dim''': 12,
                  '''embedding_dim''': self.text_embedder_hidden_size,
                  '''num_layers''': 1,
              }
  
              lowercase			:   Tuple					   =		PriorTransformer(**SCREAMING_SNAKE_CASE__		)
              # clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
              lowercase			:   Tuple					   =		nn.Parameter(torch.ones(model.clip_std.shape		)		)
              return model
  
  
        @property
        def        __lowerCamelCase			(							self		):
              torch.manual_seed(0		)
              lowercase			:   List[Any]					   =		CLIPVisionConfig(
                  hidden_size=self.text_embedder_hidden_size							,						image_size=224							,						projection_dim=self.text_embedder_hidden_size							,						intermediate_size=37							,						num_attention_heads=4							,						num_channels=3							,						num_hidden_layers=5							,						patch_size=14							,						)
  
              lowercase			:   Optional[int]					   =		CLIPVisionModelWithProjection(SCREAMING_SNAKE_CASE__		)
              return model
  
  
        @property
        def        __lowerCamelCase			(							self		):
              lowercase			:   Tuple					   =		CLIPImageProcessor(
                  crop_size=224							,						do_center_crop=SCREAMING_SNAKE_CASE__							,						do_normalize=SCREAMING_SNAKE_CASE__							,						do_resize=SCREAMING_SNAKE_CASE__							,						image_mean=[0.48145466, 0.4578275, 0.40821073]							,						image_std=[0.26862954, 0.26130258, 0.27577711]							,						resample=3							,						size=224							,						)
  
              return image_processor
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   List[Any]					   =		self.dummy_prior
              lowercase			:   Any					   =		self.dummy_image_encoder
              lowercase			:   Optional[int]					   =		self.dummy_text_encoder
              lowercase			:   int					   =		self.dummy_tokenizer
              lowercase			:   int					   =		self.dummy_image_processor
  
              lowercase			:   Union[str, Any]					   =		UnCLIPScheduler(
                  variance_type='''fixed_small_log'''							,						prediction_type='''sample'''							,						num_train_timesteps=1000							,						clip_sample=SCREAMING_SNAKE_CASE__							,						clip_sample_range=10.0							,						)
  
              lowercase			:   str					   =		{
                  '''prior''': prior,
                  '''image_encoder''': image_encoder,
                  '''text_encoder''': text_encoder,
                  '''tokenizer''': tokenizer,
                  '''scheduler''': scheduler,
                  '''image_processor''': image_processor,
              }
  
              return components
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__=0		):
              if str(SCREAMING_SNAKE_CASE__		).startswith('''mps'''		):
                    lowercase			:   Tuple					   =		torch.manual_seed(SCREAMING_SNAKE_CASE__		)
              else:
                    lowercase			:   Optional[int]					   =		torch.Generator(device=SCREAMING_SNAKE_CASE__		).manual_seed(SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   Optional[Any]					   =		floats_tensor((1, 3, 64, 64)							,						rng=random.Random(SCREAMING_SNAKE_CASE__		)		).to(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Union[str, Any]					   =		image.cpu().permute(0							,						2							,						3							,						1		)[0]
              lowercase			:   str					   =		Image.fromarray(np.uinta(SCREAMING_SNAKE_CASE__		)		).convert('''RGB'''		).resize((256, 256)		)
  
              lowercase			:   List[Any]					   =		{
                  '''prompt''': '''horse''',
                  '''image''': init_image,
                  '''strength''': 0.5,
                  '''generator''': generator,
                  '''guidance_scale''': 4.0,
                  '''num_inference_steps''': 2,
                  '''output_type''': '''np''',
              }
              return inputs
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Any					   =		'''cpu'''
  
              lowercase			:   Dict					   =		self.get_dummy_components()
  
              lowercase			:   Optional[Any]					   =		self.pipeline_class(**SCREAMING_SNAKE_CASE__		)
              lowercase			:   Any					   =		pipe.to(SCREAMING_SNAKE_CASE__		)
  
              pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   List[Any]					   =		pipe(**self.get_dummy_inputs(SCREAMING_SNAKE_CASE__		)		)
              lowercase			:   List[str]					   =		output.image_embeds
  
              lowercase			:   str					   =		pipe(
                  **self.get_dummy_inputs(SCREAMING_SNAKE_CASE__		)							,						return_dict=SCREAMING_SNAKE_CASE__							,						)[0]
  
              lowercase			:   Union[str, Any]					   =		image[0, -10:]
              lowercase			:   Dict					   =		image_from_tuple[0, -10:]
  
              assert image.shape == (1, 32)
  
              lowercase			:   List[str]					   =		np.array(
                  [
                      0.1071284,
                      1.3330271,
                      0.61260223,
                      -0.6691065,
                      -0.3846852,
                      -1.0303661,
                      0.22716111,
                      0.03348901,
                      0.30040675,
                      -0.24805029,
                  ]		)
  
              assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
              assert np.abs(image_from_tuple_slice.flatten() - expected_slice		).max() < 1E-2
  
  
        @skip_mps
        def        __lowerCamelCase			(							self		):
              lowercase			:   str					   =		torch_device == '''cpu'''
              lowercase			:   str					   =		True
              lowercase			:   Dict					   =		False
  
              self._test_inference_batch_single_identical(
                  test_max_difference=SCREAMING_SNAKE_CASE__							,						relax_max_difference=SCREAMING_SNAKE_CASE__							,						test_mean_pixel_difference=SCREAMING_SNAKE_CASE__							,						)
  
  
  
  
  
  
        @skip_mps
        def        __lowerCamelCase			(							self		):
              lowercase			:   Union[str, Any]					   =		torch_device == '''cpu'''
              lowercase			:   List[str]					   =		False
  
              self._test_attention_slicing_forward_pass(
                  test_max_difference=SCREAMING_SNAKE_CASE__							,						test_mean_pixel_difference=SCREAMING_SNAKE_CASE__							,						)
  
  
style_context: 
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
  
  
  __a   				=      {
      '''configuration_decision_transformer''': [
          '''DECISION_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
          '''DecisionTransformerConfig''',
      ],
  }
  
  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    __a   				=      [
        '''DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''DecisionTransformerGPT2Model''',
        '''DecisionTransformerGPT2PreTrainedModel''',
        '''DecisionTransformerModel''',
        '''DecisionTransformerPreTrainedModel''',
    ]
  
  
  if TYPE_CHECKING:
    from .configuration_decision_transformer import (
        DECISION_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
        DecisionTransformerConfig,
    )
  
    try:
      if not is_torch_available():
        raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
      pass
    else:
      from .modeling_decision_transformer import (
          DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          DecisionTransformerGPTaModel,
          DecisionTransformerGPTaPreTrainedModel,
          DecisionTransformerModel,
          DecisionTransformerPreTrainedModel,
      )
  
  
  else:
    import sys
  
    __a   				=      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  