


"""simple docstring"""
import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import (
     NystromformerForMaskedLM,
     NystromformerForMultipleChoice,
     NystromformerForQuestionAnswering,
     NystromformerForSequenceClassification,
     NystromformerForTokenClassification,
     NystromformerModel,
 )
 from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST




class 	lowercase__				:





   def __init__(							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE=13      ,   SCREAMING_SNAKE_CASE=7      ,   SCREAMING_SNAKE_CASE=True      ,   SCREAMING_SNAKE_CASE=True      ,   SCREAMING_SNAKE_CASE=True      ,   SCREAMING_SNAKE_CASE=True      ,   SCREAMING_SNAKE_CASE=99      ,   SCREAMING_SNAKE_CASE=32      ,   SCREAMING_SNAKE_CASE=5      ,   SCREAMING_SNAKE_CASE=4      ,   SCREAMING_SNAKE_CASE=37      ,   SCREAMING_SNAKE_CASE="gelu"      ,   SCREAMING_SNAKE_CASE=0.1      ,   SCREAMING_SNAKE_CASE=0.1      ,   SCREAMING_SNAKE_CASE=512      ,   SCREAMING_SNAKE_CASE=16      ,   SCREAMING_SNAKE_CASE=2      ,   SCREAMING_SNAKE_CASE=0.02      ,   SCREAMING_SNAKE_CASE=3      ,   SCREAMING_SNAKE_CASE=4      ,   SCREAMING_SNAKE_CASE=None      ,   )  ->  List[Any]:
      _lowerCamelCase	:					Union[str, Any]   =		parent
      _lowerCamelCase	:					Optional[Any]   =		batch_size
      _lowerCamelCase	:					Optional[int]   =		seq_length
      _lowerCamelCase	:					Any   =		is_training
      _lowerCamelCase	:					int   =		use_input_mask
      _lowerCamelCase	:					Tuple   =		use_token_type_ids
      _lowerCamelCase	:					List[str]   =		use_labels
      _lowerCamelCase	:					Any   =		vocab_size
      _lowerCamelCase	:					Dict   =		hidden_size
      _lowerCamelCase	:					Any   =		num_hidden_layers
      _lowerCamelCase	:					Dict   =		num_attention_heads
      _lowerCamelCase	:					List[Any]   =		intermediate_size
      _lowerCamelCase	:					str   =		hidden_act
      _lowerCamelCase	:					Tuple   =		hidden_dropout_prob
      _lowerCamelCase	:					List[str]   =		attention_probs_dropout_prob
      _lowerCamelCase	:					Dict   =		max_position_embeddings
      _lowerCamelCase	:					str   =		type_vocab_size
      _lowerCamelCase	:					Any   =		type_sequence_label_size
      _lowerCamelCase	:					List[str]   =		initializer_range
      _lowerCamelCase	:					Optional[Any]   =		num_labels
      _lowerCamelCase	:					List[str]   =		num_choices
      _lowerCamelCase	:					int   =		scope





   def 		UpperCamelCase_  (							self)  ->  int:
      _lowerCamelCase	:					Any   =		ids_tensor([self.batch_size, self.seq_length]      ,   self.vocab_size)

      _lowerCamelCase	:					Union[str, Any]   =		None
      if self.use_input_mask:
         _lowerCamelCase	:					Optional[Any]   =		random_attention_mask([self.batch_size, self.seq_length])

      _lowerCamelCase	:					int   =		None
      if self.use_token_type_ids:
         _lowerCamelCase	:					str   =		ids_tensor([self.batch_size, self.seq_length]      ,   self.type_vocab_size)

      _lowerCamelCase	:					Dict   =		None
      _lowerCamelCase	:					Any   =		None
      _lowerCamelCase	:					List[Any]   =		None
      if self.use_labels:
         _lowerCamelCase	:					List[str]   =		ids_tensor([self.batch_size]      ,   self.type_sequence_label_size)
         _lowerCamelCase	:					List[str]   =		ids_tensor([self.batch_size, self.seq_length]      ,   self.num_labels)
         _lowerCamelCase	:					Dict   =		ids_tensor([self.batch_size]      ,   self.num_choices)

      _lowerCamelCase	:					int   =		self.get_config()

      return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





   def 		UpperCamelCase_  (							self)  ->  Dict:
      return NystromformerConfig(
          vocab_size=self.vocab_size      ,   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      ,   max_position_embeddings=self.max_position_embeddings      ,   type_vocab_size=self.type_vocab_size      ,   is_decoder=SCREAMING_SNAKE_CASE      ,   initializer_range=self.initializer_range      ,   )





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  List[str]:
      _lowerCamelCase	:					str   =		NystromformerModel(config=SCREAMING_SNAKE_CASE)
      model.to(SCREAMING_SNAKE_CASE)
      model.eval()
      _lowerCamelCase	:					Union[str, Any]   =		model(SCREAMING_SNAKE_CASE      ,   attention_mask=SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					List[str]   =		model(SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					List[str]   =		model(SCREAMING_SNAKE_CASE)
      self.parent.assertEqual(result.last_hidden_state.shape      ,   (self.batch_size, self.seq_length, self.hidden_size))





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  List[Any]:
      _lowerCamelCase	:					Union[str, Any]   =		NystromformerForMaskedLM(config=SCREAMING_SNAKE_CASE)
      model.to(SCREAMING_SNAKE_CASE)
      model.eval()
      _lowerCamelCase	:					Union[str, Any]   =		model(SCREAMING_SNAKE_CASE      ,   attention_mask=SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE      ,   labels=SCREAMING_SNAKE_CASE)
      self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.seq_length, self.vocab_size))





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  Any:
      _lowerCamelCase	:					List[str]   =		NystromformerForQuestionAnswering(config=SCREAMING_SNAKE_CASE)
      model.to(SCREAMING_SNAKE_CASE)
      model.eval()
      _lowerCamelCase	:					Dict   =		model(
          SCREAMING_SNAKE_CASE      ,   attention_mask=SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE      ,   start_positions=SCREAMING_SNAKE_CASE      ,   end_positions=SCREAMING_SNAKE_CASE      ,   )
      self.parent.assertEqual(result.start_logits.shape      ,   (self.batch_size, self.seq_length))
      self.parent.assertEqual(result.end_logits.shape      ,   (self.batch_size, self.seq_length))





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  Optional[Any]:
      _lowerCamelCase	:					Union[str, Any]   =		self.num_labels
      _lowerCamelCase	:					int   =		NystromformerForSequenceClassification(SCREAMING_SNAKE_CASE)
      model.to(SCREAMING_SNAKE_CASE)
      model.eval()
      _lowerCamelCase	:					str   =		model(SCREAMING_SNAKE_CASE      ,   attention_mask=SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE      ,   labels=SCREAMING_SNAKE_CASE)
      self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.num_labels))





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  int:
      _lowerCamelCase	:					Tuple   =		self.num_labels
      _lowerCamelCase	:					int   =		NystromformerForTokenClassification(config=SCREAMING_SNAKE_CASE)
      model.to(SCREAMING_SNAKE_CASE)
      model.eval()
      _lowerCamelCase	:					Union[str, Any]   =		model(SCREAMING_SNAKE_CASE      ,   attention_mask=SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE      ,   labels=SCREAMING_SNAKE_CASE)
      self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.seq_length, self.num_labels))





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE)  ->  List[str]:
      _lowerCamelCase	:					int   =		self.num_choices
      _lowerCamelCase	:					Any   =		NystromformerForMultipleChoice(config=SCREAMING_SNAKE_CASE)
      model.to(SCREAMING_SNAKE_CASE)
      model.eval()
      _lowerCamelCase	:					Optional[Any]   =		input_ids.unsqueeze(1).expand(-1      ,   self.num_choices      ,   -1).contiguous()
      _lowerCamelCase	:					List[str]   =		token_type_ids.unsqueeze(1).expand(-1      ,   self.num_choices      ,   -1).contiguous()
      _lowerCamelCase	:					Dict   =		input_mask.unsqueeze(1).expand(-1      ,   self.num_choices      ,   -1).contiguous()
      _lowerCamelCase	:					str   =		model(
          SCREAMING_SNAKE_CASE      ,   attention_mask=SCREAMING_SNAKE_CASE      ,   token_type_ids=SCREAMING_SNAKE_CASE      ,   labels=SCREAMING_SNAKE_CASE      ,   )
      self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.num_choices))





   def 		UpperCamelCase_  (							self)  ->  List[Any]:
      _lowerCamelCase	:					Tuple   =		self.prepare_config_and_inputs()
      (
          (
          _lowerCamelCase
      )   ,    (
          _lowerCamelCase
      )   ,    (
          _lowerCamelCase
      )   ,    (
          _lowerCamelCase
      )   ,    (
          _lowerCamelCase
      )   ,    (
          _lowerCamelCase
      )   ,    (
          _lowerCamelCase
      )   ,    
      )	:					Union[str, Any]   =		config_and_inputs
      _lowerCamelCase	:					Optional[int]   =		{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
      return config, inputs_dict







@require_torch
class 	lowercase__				(					A_ ,A_ ,unittest.TestCase				):
   __UpperCAmelCase							       =					(
       (
           NystromformerModel,
           NystromformerForMaskedLM,
           NystromformerForMultipleChoice,
           NystromformerForQuestionAnswering,
           NystromformerForSequenceClassification,
           NystromformerForTokenClassification,
       )
       if is_torch_available()
       else ()
   )
   __UpperCAmelCase							       =					(
       {
           '''feature-extraction''': NystromformerModel,
           '''fill-mask''': NystromformerForMaskedLM,
           '''question-answering''': NystromformerForQuestionAnswering,
           '''text-classification''': NystromformerForSequenceClassification,
           '''token-classification''': NystromformerForTokenClassification,
           '''zero-shot''': NystromformerForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   __UpperCAmelCase							       =					False
   __UpperCAmelCase							       =					False





   def 		UpperCamelCase_  (							self)  ->  List[str]:
      _lowerCamelCase	:					Union[str, Any]   =		NystromformerModelTester(self)
      _lowerCamelCase	:					List[Any]   =		ConfigTester(self      ,   config_class=SCREAMING_SNAKE_CASE      ,   hidden_size=37)





   def 		UpperCamelCase_  (							self)  ->  str:
      self.config_tester.run_common_tests()





   def 		UpperCamelCase_  (							self)  ->  Any:
      _lowerCamelCase	:					Optional[int]   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  Tuple:
      _lowerCamelCase	:					List[Any]   =		self.model_tester.prepare_config_and_inputs()
      for type in ["absolute", "relative_key", "relative_key_query"]:
         _lowerCamelCase	:					int   =		type
         self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  int:
      _lowerCamelCase	:					List[str]   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  Union[str, Any]:
      _lowerCamelCase	:					str   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_multiple_choice(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  Optional[int]:
      _lowerCamelCase	:					List[str]   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  List[str]:
      _lowerCamelCase	:					str   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE)





   def 		UpperCamelCase_  (							self)  ->  str:
      _lowerCamelCase	:					List[Any]   =		self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE)





   @slow
   def 		UpperCamelCase_  (							self)  ->  Optional[int]:
      for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _lowerCamelCase	:					Dict   =		NystromformerModel.from_pretrained(SCREAMING_SNAKE_CASE)
         self.assertIsNotNone(SCREAMING_SNAKE_CASE)







@require_torch
class 	lowercase__				(					unittest.TestCase				):





   @slow
   def 		UpperCamelCase_  (							self)  ->  Optional[Any]:
      _lowerCamelCase	:					Union[str, Any]   =		NystromformerModel.from_pretrained("""uw-madison/nystromformer-512""")
      _lowerCamelCase	:					Union[str, Any]   =		torch.tensor([[0, 1, 2, 3, 4, 5]])

      with torch.no_grad():
         _lowerCamelCase	:					List[Any]   =		model(SCREAMING_SNAKE_CASE)[0]

      _lowerCamelCase	:					Any   =		torch.Size((1, 6, 768))
      self.assertEqual(output.shape      ,   SCREAMING_SNAKE_CASE)

      _lowerCamelCase	:					List[str]   =		torch.tensor(
          [[[-0.45_32, -0.09_36, 0.51_37], [-0.26_76, 0.06_28, 0.61_86], [-0.36_29, -0.17_26, 0.47_16]]])

      self.assertTrue(torch.allclose(output[:, :3, :3]      ,   SCREAMING_SNAKE_CASE      ,   atol=1e-4))





   @slow
   def 		UpperCamelCase_  (							self)  ->  Optional[Any]:
      _lowerCamelCase	:					Optional[Any]   =		"""the [MASK] of Belgium is Brussels"""

      _lowerCamelCase	:					Optional[Any]   =		AutoTokenizer.from_pretrained("""uw-madison/nystromformer-512""")
      _lowerCamelCase	:					List[Any]   =		NystromformerForMaskedLM.from_pretrained("""uw-madison/nystromformer-512""")

      _lowerCamelCase	:					str   =		tokenizer(SCREAMING_SNAKE_CASE      ,   return_tensors="""pt""")

      with torch.no_grad():
         _lowerCamelCase	:					Tuple   =		model(encoding.input_ids).logits

      _lowerCamelCase	:					str   =		token_logits[:, 2, :].argmax(-1)[0]

      self.assertEqual(tokenizer.decode(SCREAMING_SNAKE_CASE)      ,   """capital""")





"""simple docstring"""
import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    UNetaDConditionModel,
)
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 PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()




class 	lowercase__				(					A_ ,A_ ,unittest.TestCase				):
   __UpperCAmelCase							       =					StableDiffusionSAGPipeline
   __UpperCAmelCase							       =					TEXT_TO_IMAGE_PARAMS
   __UpperCAmelCase							       =					TEXT_TO_IMAGE_BATCH_PARAMS
   __UpperCAmelCase							       =					TEXT_TO_IMAGE_IMAGE_PARAMS
   __UpperCAmelCase							       =					TEXT_TO_IMAGE_IMAGE_PARAMS
   __UpperCAmelCase							       =					False





   def 		UpperCamelCase_  (							self)  ->  Optional[Any]:
      torch.manual_seed(0)
      _lowerCamelCase	:					Dict   =		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      ,   )
      _lowerCamelCase	:					int   =		DDIMScheduler(
          beta_start=0.0_00_85      ,   beta_end=0.0_12      ,   beta_schedule="""scaled_linear"""      ,   clip_sample=SCREAMING_SNAKE_CASE      ,   set_alpha_to_one=SCREAMING_SNAKE_CASE      ,   )
      torch.manual_seed(0)
      _lowerCamelCase	:					Tuple   =		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      ,   )
      torch.manual_seed(0)
      _lowerCamelCase	:					Tuple   =		CLIPTextConfig(
          bos_token_id=0      ,   eos_token_id=2      ,   hidden_size=32      ,   intermediate_size=37      ,   layer_norm_eps=1e-0_5      ,   num_attention_heads=4      ,   num_hidden_layers=5      ,   pad_token_id=1      ,   vocab_size=1000      ,   )
      _lowerCamelCase	:					List[Any]   =		CLIPTextModel(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					Tuple   =		CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""")

      _lowerCamelCase	:					List[Any]   =		{
          """unet""": unet,
          """scheduler""": scheduler,
          """vae""": vae,
          """text_encoder""": text_encoder,
          """tokenizer""": tokenizer,
          """safety_checker""": None,
          """feature_extractor""": None,
      }
      return components





   def 		UpperCamelCase_  (							self      ,   SCREAMING_SNAKE_CASE      ,   SCREAMING_SNAKE_CASE=0)  ->  List[Any]:
      if str(SCREAMING_SNAKE_CASE).startswith("""mps"""):
         _lowerCamelCase	:					List[str]   =		torch.manual_seed(SCREAMING_SNAKE_CASE)
      else:
         _lowerCamelCase	:					List[str]   =		torch.Generator(device=SCREAMING_SNAKE_CASE).manual_seed(SCREAMING_SNAKE_CASE)
      _lowerCamelCase	:					List[Any]   =		{
          """prompt""": """.""",
          """generator""": generator,
          """num_inference_steps""": 2,
          """guidance_scale""": 1.0,
          """sag_scale""": 1.0,
          """output_type""": """numpy""",
      }
      return inputs





   def 		UpperCamelCase_  (							self)  ->  Tuple:
      super().test_inference_batch_single_identical(expected_max_diff=3e-3)







@slow
@require_torch_gpu
class 	lowercase__				(					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[Any]:
      _lowerCamelCase	:					Any   =		StableDiffusionSAGPipeline.from_pretrained("""CompVis/stable-diffusion-v1-4""")
      _lowerCamelCase	:					Union[str, Any]   =		sag_pipe.to(SCREAMING_SNAKE_CASE)
      sag_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE)

      _lowerCamelCase	:					Optional[int]   =		"""."""
      _lowerCamelCase	:					int   =		torch.manual_seed(0)
      _lowerCamelCase	:					Tuple   =		sag_pipe(
          [prompt]      ,   generator=SCREAMING_SNAKE_CASE      ,   guidance_scale=7.5      ,   sag_scale=1.0      ,   num_inference_steps=20      ,   output_type="""np""")

      _lowerCamelCase	:					Dict   =		output.images

      _lowerCamelCase	:					Tuple   =		image[0, -3:, -3:, -1]

      assert image.shape == (1, 512, 512, 3)
      _lowerCamelCase	:					Optional[Any]   =		np.array([0.15_68, 0.17_38, 0.16_95, 0.16_93, 0.15_07, 0.17_05, 0.15_47, 0.17_51, 0.19_49])

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





   def 		UpperCamelCase_  (							self)  ->  List[str]:
      _lowerCamelCase	:					Optional[Any]   =		StableDiffusionSAGPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base""")
      _lowerCamelCase	:					Dict   =		sag_pipe.to(SCREAMING_SNAKE_CASE)
      sag_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE)

      _lowerCamelCase	:					Union[str, Any]   =		"""."""
      _lowerCamelCase	:					List[str]   =		torch.manual_seed(0)
      _lowerCamelCase	:					int   =		sag_pipe(
          [prompt]      ,   generator=SCREAMING_SNAKE_CASE      ,   guidance_scale=7.5      ,   sag_scale=1.0      ,   num_inference_steps=20      ,   output_type="""np""")

      _lowerCamelCase	:					Any   =		output.images

      _lowerCamelCase	:					List[str]   =		image[0, -3:, -3:, -1]

      assert image.shape == (1, 512, 512, 3)
      _lowerCamelCase	:					Any   =		np.array([0.34_59, 0.28_76, 0.25_37, 0.30_02, 0.26_71, 0.21_60, 0.30_26, 0.22_62, 0.23_71])

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





   def 		UpperCamelCase_  (							self)  ->  List[str]:
      _lowerCamelCase	:					int   =		StableDiffusionSAGPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base""")
      _lowerCamelCase	:					Optional[Any]   =		sag_pipe.to(SCREAMING_SNAKE_CASE)
      sag_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE)

      _lowerCamelCase	:					Dict   =		"""."""
      _lowerCamelCase	:					Union[str, Any]   =		torch.manual_seed(0)
      _lowerCamelCase	:					Optional[int]   =		sag_pipe(
          [prompt]      ,   width=768      ,   height=512      ,   generator=SCREAMING_SNAKE_CASE      ,   guidance_scale=7.5      ,   sag_scale=1.0      ,   num_inference_steps=20      ,   output_type="""np"""      ,   )

      _lowerCamelCase	:					Union[str, Any]   =		output.images

      assert image.shape == (1, 512, 768, 3)

