import inspect
import unittest

from transformers import YolosConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch
      from torch import nn

      from transformers import YolosForObjectDetection, YolosModel
      from transformers.models.yolos.modeling_yolos import YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
      from PIL import Image

      from transformers import AutoImageProcessor






class 		_lowerCamelCase		:
    def __init__(  self , lowerCAmelCase , lowerCAmelCase=13 , lowerCAmelCase=[30, 30] , lowerCAmelCase=2 , lowerCAmelCase=3 , lowerCAmelCase=True , lowerCAmelCase=True , lowerCAmelCase=32 , lowerCAmelCase=5 , lowerCAmelCase=4 , lowerCAmelCase=37 , lowerCAmelCase="gelu" , lowerCAmelCase=0.1 , lowerCAmelCase=0.1 , lowerCAmelCase=10 , lowerCAmelCase=0.02 , lowerCAmelCase=3 , lowerCAmelCase=None , lowerCAmelCase=8 , lowerCAmelCase=10 , )       ->					str:
     SCREAMING_SNAKE_CASE__:   Dict=      parent
     SCREAMING_SNAKE_CASE__:   Dict=      batch_size
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      image_size
     SCREAMING_SNAKE_CASE__:   int=      patch_size
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      num_channels
     SCREAMING_SNAKE_CASE__:   List[Any]=      is_training
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      use_labels
     SCREAMING_SNAKE_CASE__:   Any=      hidden_size
     SCREAMING_SNAKE_CASE__:   Tuple=      num_hidden_layers
     SCREAMING_SNAKE_CASE__:   str=      num_attention_heads
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      intermediate_size
     SCREAMING_SNAKE_CASE__:   Tuple=      hidden_act
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      hidden_dropout_prob
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      attention_probs_dropout_prob
     SCREAMING_SNAKE_CASE__:   List[str]=      type_sequence_label_size
     SCREAMING_SNAKE_CASE__:   Dict=      initializer_range
     SCREAMING_SNAKE_CASE__:   List[Any]=      num_labels
     SCREAMING_SNAKE_CASE__:   str=      scope
     SCREAMING_SNAKE_CASE__:   Optional[int]=      n_targets
     SCREAMING_SNAKE_CASE__:   Optional[int]=      num_detection_tokens
     # we set the expected sequence length (which is used in several tests)
     # expected sequence length = num_patches + 1 (we add 1 for the [CLS] token) + num_detection_tokens
     SCREAMING_SNAKE_CASE__:   Any=      (image_size[1] // patch_size) * (image_size[0] // patch_size)
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      num_patches + 1 + self.num_detection_tokens
    def 						UpperCamelCase_				(  self   )       ->					List[Any]:
     SCREAMING_SNAKE_CASE__:   Optional[int]=      floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]   )

     SCREAMING_SNAKE_CASE__:   Dict=      None
     if self.use_labels:
      # labels is a list of Dict (each Dict being the labels for a given example in the batch)
      SCREAMING_SNAKE_CASE__:   Any=      []
      for i in range(self.batch_size   ):
       SCREAMING_SNAKE_CASE__:   Optional[Any]=      {}
       SCREAMING_SNAKE_CASE__:   Union[str, Any]=      torch.randint(
           high=self.num_labels , size=(self.n_targets,) , device=lowerCAmelCase   )
       SCREAMING_SNAKE_CASE__:   str=      torch.rand(self.n_targets , 4 , device=lowerCAmelCase   )
       labels.append(lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   Dict=      self.get_config()

     return config, pixel_values, labels
    def 						UpperCamelCase_				(  self   )       ->					Dict:
     return YolosConfig(
         image_size=self.image_size , patch_size=self.patch_size , num_channels=self.num_channels , hidden_size=self.hidden_size , num_hidden_layers=self.num_hidden_layers , num_attention_heads=self.num_attention_heads , intermediate_size=self.intermediate_size , hidden_act=self.hidden_act , hidden_dropout_prob=self.hidden_dropout_prob , attention_probs_dropout_prob=self.attention_probs_dropout_prob , is_decoder=lowerCAmelCase , initializer_range=self.initializer_range , num_detection_tokens=self.num_detection_tokens , num_labels=self.num_labels , )
    def 						UpperCamelCase_				(  self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase   )       ->					str:
     SCREAMING_SNAKE_CASE__:   Tuple=      YolosModel(config=lowerCAmelCase   )
     model.to(lowerCAmelCase   )
     model.eval()
     SCREAMING_SNAKE_CASE__:   str=      model(lowerCAmelCase   )
     self.parent.assertEqual(
         result.last_hidden_state.shape , (self.batch_size, self.expected_seq_len, self.hidden_size)   )
    def 						UpperCamelCase_				(  self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase   )       ->					Any:
     SCREAMING_SNAKE_CASE__:   List[str]=      YolosForObjectDetection(lowerCAmelCase   )
     model.to(lowerCAmelCase   )
     model.eval()

     SCREAMING_SNAKE_CASE__:   Optional[int]=      model(pixel_values=lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   str=      model(lowerCAmelCase   )

     self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_detection_tokens, self.num_labels + 1)   )
     self.parent.assertEqual(result.pred_boxes.shape , (self.batch_size, self.num_detection_tokens, 4)   )

     SCREAMING_SNAKE_CASE__:   List[Any]=      model(pixel_values=lowerCAmelCase , labels=lowerCAmelCase   )

     self.parent.assertEqual(result.loss.shape , ()   )
     self.parent.assertEqual(result.logits.shape , (self.batch_size, self.num_detection_tokens, self.num_labels + 1)   )
     self.parent.assertEqual(result.pred_boxes.shape , (self.batch_size, self.num_detection_tokens, 4)   )



    def 						UpperCamelCase_				(  self   )       ->					Any:
     SCREAMING_SNAKE_CASE__:   Any=      self.prepare_config_and_inputs()
     SCREAMING_SNAKE_CASE__,	SCREAMING_SNAKE_CASE__,	SCREAMING_SNAKE_CASE__:   Optional[int]=      config_and_inputs
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      {'''pixel_values''': pixel_values}
     return config, inputs_dict






@require_torch
class 		_lowerCamelCase		(   UpperCamelCase_    ,     UpperCamelCase_    ,     unittest.TestCase    ):
    __a  =      (YolosModel, YolosForObjectDetection) if is_torch_available() else ()
    __a  =      (
        {"feature-extraction": YolosModel, "object-detection": YolosForObjectDetection} if is_torch_available() else {}
    )

    __a  =      False
    __a  =      False
    __a  =      False
    __a  =      False
    def 						UpperCamelCase_				(  self , lowerCAmelCase , lowerCAmelCase , lowerCAmelCase=False   )       ->					str:
     SCREAMING_SNAKE_CASE__:   Optional[int]=      super()._prepare_for_class(lowerCAmelCase , lowerCAmelCase , return_labels=lowerCAmelCase   )

     if return_labels:
      if model_class.__name__ == "YolosForObjectDetection":
       SCREAMING_SNAKE_CASE__:   Any=      []
       for i in range(self.model_tester.batch_size   ):
        SCREAMING_SNAKE_CASE__:   List[Any]=      {}
        SCREAMING_SNAKE_CASE__:   int=      torch.ones(
            size=(self.model_tester.n_targets,) , device=lowerCAmelCase , dtype=torch.long   )
        SCREAMING_SNAKE_CASE__:   Union[str, Any]=      torch.ones(
            self.model_tester.n_targets , 4 , device=lowerCAmelCase , dtype=torch.float   )
        labels.append(lowerCAmelCase   )
       SCREAMING_SNAKE_CASE__:   Union[str, Any]=      labels

     return inputs_dict
    def 						UpperCamelCase_				(  self   )       ->					Dict:
     SCREAMING_SNAKE_CASE__:   str=      YolosModelTester(self   )
     SCREAMING_SNAKE_CASE__:   str=      ConfigTester(self , config_class=lowerCAmelCase , has_text_modality=lowerCAmelCase , hidden_size=37   )
    def 						UpperCamelCase_				(  self   )       ->					Dict:
     self.config_tester.run_common_tests()
    def 						UpperCamelCase_				(  self   )       ->					int:
     # YOLOS does not use inputs_embeds
     pass
    def 						UpperCamelCase_				(  self   )       ->					List[Any]:
     SCREAMING_SNAKE_CASE__,	SCREAMING_SNAKE_CASE__:   Any=      self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
      SCREAMING_SNAKE_CASE__:   Dict=      model_class(lowerCAmelCase   )
      self.assertIsInstance(model.get_input_embeddings() , (nn.Module)   )
      SCREAMING_SNAKE_CASE__:   List[str]=      model.get_output_embeddings()
      self.assertTrue(x is None or isinstance(lowerCAmelCase , nn.Linear   )   )
    def 						UpperCamelCase_				(  self   )       ->					Union[str, Any]:
     SCREAMING_SNAKE_CASE__,	SCREAMING_SNAKE_CASE__:   Tuple=      self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
      SCREAMING_SNAKE_CASE__:   Any=      model_class(lowerCAmelCase   )
      SCREAMING_SNAKE_CASE__:   Any=      inspect.signature(model.forward   )
      # signature.parameters is an OrderedDict => so arg_names order is deterministic
      SCREAMING_SNAKE_CASE__:   Optional[int]=      [*signature.parameters.keys()]

      SCREAMING_SNAKE_CASE__:   List[str]=      ['''pixel_values''']
      self.assertListEqual(arg_names[:1] , lowerCAmelCase   )
    def 						UpperCamelCase_				(  self   )       ->					Dict:
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowerCAmelCase   )
    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     SCREAMING_SNAKE_CASE__,	SCREAMING_SNAKE_CASE__:   Optional[int]=      self.model_tester.prepare_config_and_inputs_for_common()
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      True

     # in YOLOS, the seq_len is different
     SCREAMING_SNAKE_CASE__:   List[str]=      self.model_tester.expected_seq_len
     for model_class in self.all_model_classes:
      SCREAMING_SNAKE_CASE__:   List[Any]=      True
      SCREAMING_SNAKE_CASE__:   Optional[int]=      False
      SCREAMING_SNAKE_CASE__:   Any=      True
      SCREAMING_SNAKE_CASE__:   int=      model_class(lowerCAmelCase   )
      model.to(lowerCAmelCase   )
      model.eval()
      with torch.no_grad():
       SCREAMING_SNAKE_CASE__:   int=      model(**self._prepare_for_class(lowerCAmelCase , lowerCAmelCase   )   )
      SCREAMING_SNAKE_CASE__:   Optional[Any]=      outputs.attentions
      self.assertEqual(len(lowerCAmelCase   ) , self.model_tester.num_hidden_layers   )

      # check that output_attentions also work using config
      del inputs_dict["output_attentions"]
      SCREAMING_SNAKE_CASE__:   Optional[int]=      True
      SCREAMING_SNAKE_CASE__:   str=      model_class(lowerCAmelCase   )
      model.to(lowerCAmelCase   )
      model.eval()
      with torch.no_grad():
       SCREAMING_SNAKE_CASE__:   List[Any]=      model(**self._prepare_for_class(lowerCAmelCase , lowerCAmelCase   )   )
      SCREAMING_SNAKE_CASE__:   Any=      outputs.attentions
      self.assertEqual(len(lowerCAmelCase   ) , self.model_tester.num_hidden_layers   )

      self.assertListEqual(
          list(attentions[0].shape[-3:]   ) , [self.model_tester.num_attention_heads, seq_len, seq_len] , )
      SCREAMING_SNAKE_CASE__:   Optional[int]=      len(lowerCAmelCase   )

      # Check attention is always last and order is fine
      SCREAMING_SNAKE_CASE__:   Tuple=      True
      SCREAMING_SNAKE_CASE__:   Union[str, Any]=      True
      SCREAMING_SNAKE_CASE__:   Union[str, Any]=      model_class(lowerCAmelCase   )
      model.to(lowerCAmelCase   )
      model.eval()
      with torch.no_grad():
       SCREAMING_SNAKE_CASE__:   Any=      model(**self._prepare_for_class(lowerCAmelCase , lowerCAmelCase   )   )

      SCREAMING_SNAKE_CASE__:   Dict=      1
      self.assertEqual(out_len + added_hidden_states , len(lowerCAmelCase   )   )

      SCREAMING_SNAKE_CASE__:   int=      outputs.attentions

      self.assertEqual(len(lowerCAmelCase   ) , self.model_tester.num_hidden_layers   )
      self.assertListEqual(
          list(self_attentions[0].shape[-3:]   ) , [self.model_tester.num_attention_heads, seq_len, seq_len] , )
    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     def check_hidden_states_output(lowerCAmelCase , lowerCAmelCase , lowerCAmelCase   ):
      SCREAMING_SNAKE_CASE__:   List[Any]=      model_class(lowerCAmelCase   )
      model.to(lowerCAmelCase   )
      model.eval()

      with torch.no_grad():
       SCREAMING_SNAKE_CASE__:   str=      model(**self._prepare_for_class(lowerCAmelCase , lowerCAmelCase   )   )

      SCREAMING_SNAKE_CASE__:   Tuple=      outputs.hidden_states

      SCREAMING_SNAKE_CASE__:   Optional[int]=      getattr(
          self.model_tester , '''expected_num_hidden_layers''' , self.model_tester.num_hidden_layers + 1   )
      self.assertEqual(len(lowerCAmelCase   ) , lowerCAmelCase   )

      # YOLOS has a different seq_length
      SCREAMING_SNAKE_CASE__:   List[str]=      self.model_tester.expected_seq_len

      self.assertListEqual(
          list(hidden_states[0].shape[-2:]   ) , [seq_length, self.model_tester.hidden_size] , )

     SCREAMING_SNAKE_CASE__,	SCREAMING_SNAKE_CASE__:   Tuple=      self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
      SCREAMING_SNAKE_CASE__:   Union[str, Any]=      True
      check_hidden_states_output(lowerCAmelCase , lowerCAmelCase , lowerCAmelCase   )

      # check that output_hidden_states also work using config
      del inputs_dict["output_hidden_states"]
      SCREAMING_SNAKE_CASE__:   str=      True

      check_hidden_states_output(lowerCAmelCase , lowerCAmelCase , lowerCAmelCase   )
    def 						UpperCamelCase_				(  self   )       ->					Union[str, Any]:
     SCREAMING_SNAKE_CASE__:   Any=      self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_object_detection(*lowerCAmelCase   )



    @slow
    def 						UpperCamelCase_				(  self   )       ->					int:
     for model_name in YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
      SCREAMING_SNAKE_CASE__:   Tuple=      YolosModel.from_pretrained(lowerCAmelCase   )
      self.assertIsNotNone(lowerCAmelCase   )







def 			A__      (	):
 SCREAMING_SNAKE_CASE__:   List[Any]=      Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
 return image






@require_torch
@require_vision
class 		_lowerCamelCase		(   unittest.TestCase    ):
    @cached_property
    def 						UpperCamelCase_				(  self   )       ->					Any:
     return AutoImageProcessor.from_pretrained('''hustvl/yolos-small'''   ) if is_vision_available() else None



    @slow
    def 						UpperCamelCase_				(  self   )       ->					List[Any]:
     SCREAMING_SNAKE_CASE__:   int=      YolosForObjectDetection.from_pretrained('''hustvl/yolos-small'''   ).to(lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   Dict=      self.default_image_processor
     SCREAMING_SNAKE_CASE__:   List[Any]=      prepare_img()
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      image_processor(images=lowerCAmelCase , return_tensors='''pt'''   ).to(lowerCAmelCase   )

     # forward pass
     with torch.no_grad():
      SCREAMING_SNAKE_CASE__:   List[str]=      model(inputs.pixel_values   )

     # verify outputs
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      torch.Size((1, 100, 92)   )
     self.assertEqual(outputs.logits.shape , lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   Dict=      torch.tensor(
         [[-24.0248, -10.3024, -14.8290], [-42.0392, -16.8200, -27.4334], [-27.2743, -11.8154, -18.7148]] , device=lowerCAmelCase , )
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      torch.tensor(
         [[0.2559, 0.5455, 0.4706], [0.2989, 0.7279, 0.1875], [0.7732, 0.4017, 0.4462]] , device=lowerCAmelCase   )
     self.assertTrue(torch.allclose(outputs.logits[0, :3, :3] , lowerCAmelCase , atol=1e-4   )   )
     self.assertTrue(torch.allclose(outputs.pred_boxes[0, :3, :3] , lowerCAmelCase , atol=1e-4   )   )

     # verify postprocessing
     SCREAMING_SNAKE_CASE__:   List[str]=      image_processor.post_process_object_detection(
         lowerCAmelCase , threshold=0.3 , target_sizes=[image.size[::-1]]   )[0]
     SCREAMING_SNAKE_CASE__:   List[str]=      torch.tensor([0.9994, 0.9790, 0.9964, 0.9972, 0.9861]   ).to(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   str=      [75, 75, 17, 63, 17]
     SCREAMING_SNAKE_CASE__:   str=      torch.tensor([335.0609, 79.3848, 375.4216, 187.2495]   ).to(lowerCAmelCase   )

     self.assertEqual(len(results['''scores''']   ) , 5   )
     self.assertTrue(torch.allclose(results['''scores'''] , lowerCAmelCase , atol=1e-4   )   )
     self.assertSequenceEqual(results['''labels'''].tolist() , lowerCAmelCase   )
     self.assertTrue(torch.allclose(results['''boxes'''][0, :] , lowerCAmelCase   )   )


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		(   UpperCamelCase_    ,     UpperCamelCase_    ,     UpperCamelCase_    ,     unittest.TestCase    ):
    __a  =      AltDiffusionPipeline
    __a  =      TEXT_TO_IMAGE_PARAMS
    __a  =      TEXT_TO_IMAGE_BATCH_PARAMS
    __a  =      TEXT_TO_IMAGE_IMAGE_PARAMS
    __a  =      TEXT_TO_IMAGE_IMAGE_PARAMS
    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   List[Any]=      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 , )
     SCREAMING_SNAKE_CASE__:   Tuple=      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   )
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      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   )
     SCREAMING_SNAKE_CASE__:   Tuple=      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 , )
     SCREAMING_SNAKE_CASE__:   List[Any]=      CLIPTextModel(lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   List[Any]=      XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''   )
     SCREAMING_SNAKE_CASE__:   List[Any]=      77

     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      {
         '''unet''': unet,
         '''scheduler''': scheduler,
         '''vae''': vae,
         '''text_encoder''': text_encoder,
         '''tokenizer''': tokenizer,
         '''safety_checker''': None,
         '''feature_extractor''': None,
     }
     return components
    def 						UpperCamelCase_				(  self , lowerCAmelCase , lowerCAmelCase=0   )       ->					List[Any]:
     if str(lowerCAmelCase   ).startswith('''mps'''   ):
      SCREAMING_SNAKE_CASE__:   Any=      torch.manual_seed(lowerCAmelCase   )
     else:
      SCREAMING_SNAKE_CASE__:   Union[str, Any]=      torch.Generator(device=lowerCAmelCase   ).manual_seed(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Any=      {
         '''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 						UpperCamelCase_				(  self   )       ->					List[str]:
     super().test_attention_slicing_forward_pass(expected_max_diff=3e-3   )
    def 						UpperCamelCase_				(  self   )       ->					Tuple:
     super().test_inference_batch_single_identical(expected_max_diff=3e-3   )
    def 						UpperCamelCase_				(  self   )       ->					Optional[Any]:
     SCREAMING_SNAKE_CASE__:   Optional[int]=      '''cpu'''  # ensure determinism for the device-dependent torch.Generator

     SCREAMING_SNAKE_CASE__:   Tuple=      self.get_dummy_components()
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   List[Any]=      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
     SCREAMING_SNAKE_CASE__:   List[str]=      RobertaSeriesModelWithTransformation(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   List[str]=      text_encoder

     SCREAMING_SNAKE_CASE__:   List[Any]=      AltDiffusionPipeline(**lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      alt_pipe.to(lowerCAmelCase   )
     alt_pipe.set_progress_bar_config(disable=lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   str=      self.get_dummy_inputs(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Dict=      '''A photo of an astronaut'''
     SCREAMING_SNAKE_CASE__:   Any=      alt_pipe(**lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[int]=      output.images
     SCREAMING_SNAKE_CASE__:   Tuple=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 64, 64, 3)
     SCREAMING_SNAKE_CASE__:   Any=      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 						UpperCamelCase_				(  self   )       ->					Optional[int]:
     SCREAMING_SNAKE_CASE__:   List[str]=      '''cpu'''  # ensure determinism for the device-dependent torch.Generator

     SCREAMING_SNAKE_CASE__:   Any=      self.get_dummy_components()
     SCREAMING_SNAKE_CASE__:   List[str]=      PNDMScheduler(skip_prk_steps=lowerCAmelCase   )
     torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   Tuple=      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
     SCREAMING_SNAKE_CASE__:   str=      RobertaSeriesModelWithTransformation(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   List[str]=      text_encoder
     SCREAMING_SNAKE_CASE__:   Any=      AltDiffusionPipeline(**lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   List[str]=      alt_pipe.to(lowerCAmelCase   )
     alt_pipe.set_progress_bar_config(disable=lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   List[Any]=      self.get_dummy_inputs(lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[int]=      alt_pipe(**lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      output.images
     SCREAMING_SNAKE_CASE__:   Tuple=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 64, 64, 3)
     SCREAMING_SNAKE_CASE__:   List[Any]=      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 						UpperCamelCase_				(  self   )       ->					Union[str, Any]:
     # clean up the VRAM after each test
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()
    def 						UpperCamelCase_				(  self   )       ->					Optional[int]:
     # make sure here that pndm scheduler skips prk
     SCREAMING_SNAKE_CASE__:   Any=      AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion''' , safety_checker=lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      alt_pipe.to(lowerCAmelCase   )
     alt_pipe.set_progress_bar_config(disable=lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   Dict=      '''A painting of a squirrel eating a burger'''
     SCREAMING_SNAKE_CASE__:   Union[str, Any]=      torch.manual_seed(0   )
     SCREAMING_SNAKE_CASE__:   Tuple=      alt_pipe([prompt] , generator=lowerCAmelCase , guidance_scale=6.0 , num_inference_steps=20 , output_type='''np'''   )

     SCREAMING_SNAKE_CASE__:   List[Any]=      output.images

     SCREAMING_SNAKE_CASE__:   Dict=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     SCREAMING_SNAKE_CASE__:   Optional[int]=      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 						UpperCamelCase_				(  self   )       ->					Union[str, Any]:
     SCREAMING_SNAKE_CASE__:   List[Any]=      DDIMScheduler.from_pretrained('''BAAI/AltDiffusion''' , subfolder='''scheduler'''   )

     SCREAMING_SNAKE_CASE__:   List[str]=      AltDiffusionPipeline.from_pretrained('''BAAI/AltDiffusion''' , scheduler=lowerCAmelCase , safety_checker=lowerCAmelCase   )
     SCREAMING_SNAKE_CASE__:   Optional[int]=      alt_pipe.to(lowerCAmelCase   )
     alt_pipe.set_progress_bar_config(disable=lowerCAmelCase   )

     SCREAMING_SNAKE_CASE__:   Optional[Any]=      '''A painting of a squirrel eating a burger'''
     SCREAMING_SNAKE_CASE__:   Any=      torch.manual_seed(0   )

     SCREAMING_SNAKE_CASE__:   str=      alt_pipe([prompt] , generator=lowerCAmelCase , num_inference_steps=2 , output_type='''numpy'''   )
     SCREAMING_SNAKE_CASE__:   List[str]=      output.images

     SCREAMING_SNAKE_CASE__:   Dict=      image[0, -3:, -3:, -1]

     assert image.shape == (1, 512, 512, 3)
     SCREAMING_SNAKE_CASE__:   Optional[Any]=      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

