"""simple docstring"""


import gc
import importlib.metadata
import tempfile
import unittest

from packaging import version

from transformers import (
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    BitsAndBytesConfig,
    pipeline,
)
from transformers.testing_utils import (
    is_torch_available,
    require_accelerate,
    require_bitsandbytes,
    require_torch,
    require_torch_gpu,
    require_torch_multi_gpu,
    slow,
)






def     __UpperCAmelCase					(			lowercase		):







  """simple docstring"""
  if model.config.model_type == "gpt2":
    return model.transformer.h[0].mlp.c_fc
  return model.transformer.h[0].mlp.dense_ah_to_h


if is_torch_available():
      import torch
      import torch.nn as nn


      class        a				(		nn.Module   ):


          def __init__(					self	:  Any   ,				__lowerCAmelCase	:  nn.Module   ,				__lowerCAmelCase	:  int					):
            super().__init__()
            _UpperCAmelCase						 =      module
            _UpperCAmelCase						 =      nn.Sequential(
                nn.Linear(module.in_features   ,				__A   ,				bias=__A					)   ,				nn.Linear(__A   ,				module.out_features   ,				bias=__A					)   ,				)
            _UpperCAmelCase						 =      (2.0 / (5 * min(module.in_features   ,				module.out_features					))) ** 0.5
            nn.init.normal_(self.adapter[0].weight   ,				std=__A					)
            nn.init.zeros_(self.adapter[1].weight					)
            self.adapter.to(module.weight.device					)


          def      lowerCAmelCase_  (					self	:  Optional[Any]   ,				__lowerCAmelCase	:  int   ,				*__lowerCAmelCase	:  Optional[int]   ,				**__lowerCAmelCase	:  Optional[Any]					):
            return self.module(__A   ,				*__A   ,				**__A					) + self.adapter(__A					)


@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class        a				(		unittest.TestCase   ):
    _snake_case     :  Tuple     							=							'bigscience/bloom-1b7'

    # Constant values
    _snake_case     :  List[Any]     							=							2.1_09_65_95_52_69_25_74

    _snake_case     :  Optional[int]     							=							'Hello my name is'
    _snake_case     :  str     							=							set()
    EXPECTED_OUTPUTS.add('Hello my name is John and I am a professional photographer. I'   )
    EXPECTED_OUTPUTS.add('Hello my name is John.\nI am a friend of your father.\n'   )
    EXPECTED_OUTPUTS.add('Hello my name is John Doe, I am a student at the University'   )
    _snake_case     :  Any     							=							10


    def      lowerCAmelCase_  (					self	:  Any					):
      # Models and tokenizer
      _UpperCAmelCase						 =      AutoTokenizer.from_pretrained(self.model_name					)



class        a				(		UpperCamelCase_   ):


    def      lowerCAmelCase_  (					self	:  Union[str, Any]					):
      super().setUp()

      # Models and tokenizer
      _UpperCAmelCase						 =      AutoModelForCausalLM.from_pretrained(
          self.model_name   ,				torch_dtype=torch.floataa   ,				device_map="""auto"""					)
      _UpperCAmelCase						 =      AutoModelForCausalLM.from_pretrained(self.model_name   ,				load_in_abit=__A   ,				device_map="""auto"""					)


    def      lowerCAmelCase_  (					self	:  Any					):
      del self.model_fpaa
      del self.model_abit

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


    def      lowerCAmelCase_  (					self	:  Optional[int]					):
      _UpperCAmelCase						 =      self.model_abit.config

      self.assertTrue(hasattr(__A   ,				"""quantization_config"""					)					)

      _UpperCAmelCase						 =      config.to_dict()
      _UpperCAmelCase						 =      config.to_diff_dict()

      _UpperCAmelCase						 =      config.to_json_string()


    def      lowerCAmelCase_  (					self	:  Optional[Any]					):
      from bitsandbytes.nn import Paramsabit

      _UpperCAmelCase						 =      self.model_fpaa.get_memory_footprint()
      _UpperCAmelCase						 =      self.model_abit.get_memory_footprint()

      self.assertAlmostEqual(mem_fpaa / mem_abit   ,				self.EXPECTED_RELATIVE_DIFFERENCE					)
      _UpperCAmelCase						 =      get_some_linear_layer(self.model_abit					)
      self.assertTrue(linear.weight.__class__ == Paramsabit					)


    def      lowerCAmelCase_  (					self	:  List[str]					):
      from transformers import TaPreTrainedModel

      self.model_fpaa.get_memory_footprint()
      self.model_abit.get_memory_footprint()

      for name, module in self.model_abit.named_modules():
        if isinstance(__A   ,				torch.nn.Linear					):
          if name not in ["lm_head"] + TaPreTrainedModel._keep_in_fpaa_modules:
            # 4-bit parameters are packed in uint8 variables
            self.assertTrue(module.weight.dtype == torch.uinta					)


    def      lowerCAmelCase_  (					self	:  Union[str, Any]					):
      _UpperCAmelCase						 =      self.tokenizer(self.input_text   ,				return_tensors="""pt"""					)
      _UpperCAmelCase						 =      self.model_abit.generate(input_ids=encoded_input["""input_ids"""].to(0					)   ,				max_new_tokens=10					)

      self.assertIn(self.tokenizer.decode(output_sequences[0]   ,				skip_special_tokens=__A					)   ,				self.EXPECTED_OUTPUTS					)


    def      lowerCAmelCase_  (					self	:  Optional[int]					):
      _UpperCAmelCase						 =      BitsAndBytesConfig()
      _UpperCAmelCase						 =      True

      _UpperCAmelCase						 =      AutoModelForCausalLM.from_pretrained(
          self.model_name   ,				quantization_config=__A   ,				device_map="""auto"""					)

      _UpperCAmelCase						 =      self.tokenizer(self.input_text   ,				return_tensors="""pt"""					)
      _UpperCAmelCase						 =      model_abit_from_config.generate(
          input_ids=encoded_input["""input_ids"""].to(0					)   ,				max_new_tokens=10					)

      self.assertIn(self.tokenizer.decode(output_sequences[0]   ,				skip_special_tokens=__A					)   ,				self.EXPECTED_OUTPUTS					)


    def      lowerCAmelCase_  (					self	:  List[Any]					):
      with self.assertRaises(__A					), tempfile.TemporaryDirectory() as tmpdirname:
        self.model_abit.save_pretrained(__A					)


    def      lowerCAmelCase_  (					self	:  Optional[Any]					):
      _UpperCAmelCase						 =      BitsAndBytesConfig()

      with self.assertRaises(__A					):
        _UpperCAmelCase						 =      AutoModelForCausalLM.from_pretrained(
            self.model_name   ,				quantization_config=__A   ,				load_in_abit=__A   ,				device_map="""auto"""   ,				bnb_abit_quant_type="""nf4"""   ,				)


    def      lowerCAmelCase_  (					self	:  int					):
      with self.assertRaises(__A					):
        # Tries with `str`
        self.model_abit.to("""cpu"""					)

      with self.assertRaises(__A					):
        # Tries with a `dtype``
        self.model_abit.to(torch.floataa					)

      with self.assertRaises(__A					):
        # Tries with a `device`
        self.model_abit.to(torch.device("""cuda:0"""					)					)

      with self.assertRaises(__A					):
        # Tries with a `device`
        self.model_abit.float()

      with self.assertRaises(__A					):
        # Tries with a `device`
        self.model_abit.half()

      # Test if we did not break anything
      _UpperCAmelCase						 =      self.tokenizer(self.input_text   ,				return_tensors="""pt"""					)

      _UpperCAmelCase						 =      self.model_fpaa.to(torch.floataa					)
      _UpperCAmelCase						 =      self.model_fpaa.generate(input_ids=encoded_input["""input_ids"""].to(0					)   ,				max_new_tokens=10					)

      # Check this does not throw an error
      _UpperCAmelCase						 =      self.model_fpaa.to("""cpu"""					)

      # Check this does not throw an error
      _UpperCAmelCase						 =      self.model_fpaa.half()

      # Check this does not throw an error
      _UpperCAmelCase						 =      self.model_fpaa.float()


    def      lowerCAmelCase_  (					self	:  Optional[Any]					):
      _UpperCAmelCase						 =      AutoModelForSeqaSeqLM.from_pretrained("""t5-small"""   ,				load_in_abit=__A   ,				device_map="""auto"""					)
      self.assertTrue(model.decoder.block[0].layer[2].DenseReluDense.wo.weight.dtype == torch.floataa					)



@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class        a				(		unittest.TestCase   ):


    @classmethod
    def      lowerCAmelCase_  (					cls	:  Dict					):
      _UpperCAmelCase						 =      "t5-small"
      _UpperCAmelCase						 =      "google/flan-t5-small"  # flan-t5 uses dense-act instead of dense-relu-dense
      _UpperCAmelCase						 =      AutoTokenizer.from_pretrained(cls.model_name					)
      _UpperCAmelCase						 =      "Translate in German: Hello, my dog is cute"


    def      lowerCAmelCase_  (					self	:  int					):
      gc.collect()
      torch.cuda.empty_cache()


    def      lowerCAmelCase_  (					self	:  Optional[Any]					):
      from transformers import TaForConditionalGeneration

      _UpperCAmelCase						 =      TaForConditionalGeneration._keep_in_fpaa_modules
      _UpperCAmelCase						 =      None

      # test with `t5-small`
      _UpperCAmelCase						 =      TaForConditionalGeneration.from_pretrained(self.model_name   ,				load_in_abit=__A   ,				device_map="""auto"""					)
      _UpperCAmelCase						 =      self.tokenizer(self.input_text   ,				return_tensors="""pt"""					).to(0					)
      _UpperCAmelCase						 =      model.generate(**__A					)

      # test with `flan-t5-small`
      _UpperCAmelCase						 =      TaForConditionalGeneration.from_pretrained(
          self.dense_act_model_name   ,				load_in_abit=__A   ,				device_map="""auto"""					)
      _UpperCAmelCase						 =      self.tokenizer(self.input_text   ,				return_tensors="""pt"""					).to(0					)
      _UpperCAmelCase						 =      model.generate(**__A					)
      _UpperCAmelCase						 =      modules


    def      lowerCAmelCase_  (					self	:  str					):
      import bitsandbytes as bnb

      from transformers import TaForConditionalGeneration

      # test with `t5-small`
      _UpperCAmelCase						 =      TaForConditionalGeneration.from_pretrained(self.model_name   ,				load_in_abit=__A   ,				device_map="""auto"""					)

      # there was a bug with decoders - this test checks that it is fixed
      self.assertTrue(isinstance(model.decoder.block[0].layer[0].SelfAttention.q   ,				bnb.nn.Linearabit					)					)

      _UpperCAmelCase						 =      self.tokenizer(self.input_text   ,				return_tensors="""pt"""					).to(0					)
      _UpperCAmelCase						 =      model.generate(**__A					)

      # test with `flan-t5-small`
      _UpperCAmelCase						 =      TaForConditionalGeneration.from_pretrained(
          self.dense_act_model_name   ,				load_in_abit=__A   ,				device_map="""auto"""					)
      _UpperCAmelCase						 =      self.tokenizer(self.input_text   ,				return_tensors="""pt"""					).to(0					)
      _UpperCAmelCase						 =      model.generate(**__A					)



class        a				(		UpperCamelCase_   ):


    def      lowerCAmelCase_  (					self	:  Any					):
      super().setUp()
      # model_name
      _UpperCAmelCase						 =      "bigscience/bloom-560m"
      _UpperCAmelCase						 =      "t5-small"

      # Different types of model

      _UpperCAmelCase						 =      AutoModel.from_pretrained(self.model_name   ,				load_in_abit=__A   ,				device_map="""auto"""					)
      # Sequence classification model
      _UpperCAmelCase						 =      AutoModelForSequenceClassification.from_pretrained(
          self.model_name   ,				load_in_abit=__A   ,				device_map="""auto"""					)
      # CausalLM model
      _UpperCAmelCase						 =      AutoModelForCausalLM.from_pretrained(self.model_name   ,				load_in_abit=__A   ,				device_map="""auto"""					)
      # Seq2seq model
      _UpperCAmelCase						 =      AutoModelForSeqaSeqLM.from_pretrained(
          self.seq_to_seq_name   ,				load_in_abit=__A   ,				device_map="""auto"""					)


    def      lowerCAmelCase_  (					self	:  Any					):
      del self.base_model
      del self.sequence_model
      del self.model_abit
      del self.seq_to_seq_model

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


    def      lowerCAmelCase_  (					self	:  Any					):
      from bitsandbytes.nn import Paramsabit

      self.assertTrue(self.base_model.h[-1].mlp.dense_ah_to_h.weight.__class__ == Paramsabit					)

      # Other heads should be nn.Parameter
      self.assertTrue(self.model_abit.lm_head.weight.__class__ == torch.nn.Parameter					)
      self.assertTrue(self.sequence_model.score.weight.__class__ == torch.nn.Parameter					)
      self.assertTrue(self.seq_to_seq_model.lm_head.weight.__class__ == torch.nn.Parameter					)



class        a				(		UpperCamelCase_   ):


    def      lowerCAmelCase_  (					self	:  Dict					):
      super().setUp()


    def      lowerCAmelCase_  (					self	:  Union[str, Any]					):
      del self.pipe

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


    def      lowerCAmelCase_  (					self	:  str					):
      _UpperCAmelCase						 =      pipeline(
          """text-generation"""   ,				model=self.model_name   ,				model_kwargs={"""device_map""": """auto""", """load_in_4bit""": True, """torch_dtype""": torch.floataa}   ,				max_new_tokens=self.MAX_NEW_TOKENS   ,				)

      # Real second forward pass
      _UpperCAmelCase						 =      self.pipe(self.input_text					)
      self.assertIn(pipeline_output[0]["""generated_text"""]   ,				self.EXPECTED_OUTPUTS					)



@require_torch_multi_gpu
class        a				(		UpperCamelCase_   ):


    def      lowerCAmelCase_  (					self	:  int					):
      super().setUp()


    def      lowerCAmelCase_  (					self	:  Union[str, Any]					):
      _UpperCAmelCase						 =      AutoModelForCausalLM.from_pretrained(
          self.model_name   ,				load_in_abit=__A   ,				device_map="""balanced"""					)

      # Check correct device map
      self.assertEqual(set(model_parallel.hf_device_map.values()					)   ,				{0, 1}					)

      # Check that inference pass works on the model
      _UpperCAmelCase						 =      self.tokenizer(self.input_text   ,				return_tensors="""pt"""					)

      # Second real batch
      _UpperCAmelCase						 =      model_parallel.generate(input_ids=encoded_input["""input_ids"""].to(0					)   ,				max_new_tokens=10					)
      self.assertIn(self.tokenizer.decode(output_parallel[0]   ,				skip_special_tokens=__A					)   ,				self.EXPECTED_OUTPUTS					)



class        a				(		UpperCamelCase_   ):


    def      lowerCAmelCase_  (					self	:  Optional[int]					):
      _UpperCAmelCase						 =      "facebook/opt-350m"
      super().setUp()


    def      lowerCAmelCase_  (					self	:  Dict					):
      if version.parse(importlib.metadata.version("""bitsandbytes"""					)					) < version.parse("""0.37.0"""					):
        return

      # Step 1: freeze all parameters
      _UpperCAmelCase						 =      AutoModelForCausalLM.from_pretrained(self.model_name   ,				load_in_abit=__A					)

      self.assertEqual(set(model.hf_device_map.values()					)   ,				{torch.cuda.current_device()}					)

      for param in model.parameters():
        _UpperCAmelCase						 =      False  # freeze the model - train adapters later
        if param.ndim == 1:
          # cast the small parameters (e.g. layernorm) to fp32 for stability
          _UpperCAmelCase						 =      param.data.to(torch.floataa					)

        # Step 2: add adapters
      for _, module in model.named_modules():
        if "OPTAttention" in repr(type(__A					)					):
          _UpperCAmelCase						 =      LoRALayer(module.q_proj   ,				rank=16					)
          _UpperCAmelCase						 =      LoRALayer(module.k_proj   ,				rank=16					)
          _UpperCAmelCase						 =      LoRALayer(module.v_proj   ,				rank=16					)

        # Step 3: dummy batch
      _UpperCAmelCase						 =      self.tokenizer("""Test batch """   ,				return_tensors="""pt"""					).to(0					)

      # Step 4: Check if the gradient is not None
      with torch.cuda.amp.autocast():
        _UpperCAmelCase						 =      model.forward(**__A					)
        out.logits.norm().backward()

      for module in model.modules():
        if isinstance(__A   ,				__A					):
          self.assertTrue(module.adapter[1].weight.grad is not None					)
          self.assertTrue(module.adapter[1].weight.grad.norm().item() > 0					)
        elif isinstance(__A   ,				nn.Embedding					):
          self.assertTrue(module.weight.grad is None					)



class        a				(		UpperCamelCase_   ):
    _snake_case     :  Tuple     							=							'gpt2-xl'
    _snake_case     :  Dict     							=							3.31_91_85_48_54_15_21_87

"""simple docstring"""


import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

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,
    assert_mean_pixel_difference,
)


enable_full_determinism()


class        a				(		lowerCAmelCase_	,							lowerCAmelCase_	,							lowerCAmelCase_	,							unittest.TestCase   ):
    _snake_case     :  Optional[int]     							=							StableUnCLIPPipeline
    _snake_case     :  List[str]     							=							TEXT_TO_IMAGE_PARAMS
    _snake_case     :  Tuple     							=							TEXT_TO_IMAGE_BATCH_PARAMS
    _snake_case     :  List[Any]     							=							TEXT_TO_IMAGE_IMAGE_PARAMS
    _snake_case     :  str     							=							TEXT_TO_IMAGE_IMAGE_PARAMS

    # TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
    _snake_case     :  str     							=							False


    def      lowerCAmelCase_  (					self	:  Dict					):
      _UpperCAmelCase						 =      32
      _UpperCAmelCase						 =      embedder_hidden_size

      # prior components

      torch.manual_seed(0					)
      _UpperCAmelCase						 =      CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

      torch.manual_seed(0					)
      _UpperCAmelCase						 =      CLIPTextModelWithProjection(
          CLIPTextConfig(
              bos_token_id=0   ,				eos_token_id=2   ,				hidden_size=__lowerCAmelCase   ,				projection_dim=__lowerCAmelCase   ,				intermediate_size=37   ,				layer_norm_eps=1e-0_5   ,				num_attention_heads=4   ,				num_hidden_layers=5   ,				pad_token_id=1   ,				vocab_size=1000   ,				)					)

      torch.manual_seed(0					)
      _UpperCAmelCase						 =      PriorTransformer(
          num_attention_heads=2   ,				attention_head_dim=12   ,				embedding_dim=__lowerCAmelCase   ,				num_layers=1   ,				)

      torch.manual_seed(0					)
      _UpperCAmelCase						 =      DDPMScheduler(
          variance_type="""fixed_small_log"""   ,				prediction_type="""sample"""   ,				num_train_timesteps=1000   ,				clip_sample=__lowerCAmelCase   ,				clip_sample_range=5.0   ,				beta_schedule="""squaredcos_cap_v2"""   ,				)

      # regular denoising components

      torch.manual_seed(0					)
      _UpperCAmelCase						 =      StableUnCLIPImageNormalizer(embedding_dim=__lowerCAmelCase					)
      _UpperCAmelCase						 =      DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""					)

      torch.manual_seed(0					)
      _UpperCAmelCase						 =      CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

      torch.manual_seed(0					)
      _UpperCAmelCase						 =      CLIPTextModel(
          CLIPTextConfig(
              bos_token_id=0   ,				eos_token_id=2   ,				hidden_size=__lowerCAmelCase   ,				projection_dim=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   ,				)					)

      torch.manual_seed(0					)
      _UpperCAmelCase						 =      UNetaDConditionModel(
          sample_size=32   ,				in_channels=4   ,				out_channels=4   ,				down_block_types=("""CrossAttnDownBlock2D""", """DownBlock2D""")   ,				up_block_types=("""UpBlock2D""", """CrossAttnUpBlock2D""")   ,				block_out_channels=(32, 64)   ,				attention_head_dim=(2, 4)   ,				class_embed_type="""projection"""   ,				projection_class_embeddings_input_dim=embedder_projection_dim * 2   ,				cross_attention_dim=__lowerCAmelCase   ,				layers_per_block=1   ,				upcast_attention=__lowerCAmelCase   ,				use_linear_projection=__lowerCAmelCase   ,				)

      torch.manual_seed(0					)
      _UpperCAmelCase						 =      DDIMScheduler(
          beta_schedule="""scaled_linear"""   ,				beta_start=0.00_085   ,				beta_end=0.012   ,				prediction_type="""v_prediction"""   ,				set_alpha_to_one=__lowerCAmelCase   ,				steps_offset=1   ,				)

      torch.manual_seed(0					)
      _UpperCAmelCase						 =      AutoencoderKL()

      _UpperCAmelCase						 =      {
          # prior components
          """prior_tokenizer""": prior_tokenizer,
          """prior_text_encoder""": prior_text_encoder,
          """prior""": prior,
          """prior_scheduler""": prior_scheduler,
          # image noising components
          """image_normalizer""": image_normalizer,
          """image_noising_scheduler""": image_noising_scheduler,
          # regular denoising components
          """tokenizer""": tokenizer,
          """text_encoder""": text_encoder,
          """unet""": unet,
          """scheduler""": scheduler,
          """vae""": vae,
      }

      return components


    def      lowerCAmelCase_  (					self	:  List[Any]   ,				__lowerCAmelCase	:  Any   ,				__lowerCAmelCase	:  int=0					):
      if str(__lowerCAmelCase					).startswith("""mps"""					):
        _UpperCAmelCase						 =      torch.manual_seed(__lowerCAmelCase					)
      else:
        _UpperCAmelCase						 =      torch.Generator(device=__lowerCAmelCase					).manual_seed(__lowerCAmelCase					)
      _UpperCAmelCase						 =      {
          """prompt""": """A painting of a squirrel eating a burger""",
          """generator""": generator,
          """num_inference_steps""": 2,
          """prior_num_inference_steps""": 2,
          """output_type""": """numpy""",
      }
      return inputs


    def      lowerCAmelCase_  (					self	:  List[str]					):
      _UpperCAmelCase						 =      torch_device == """cpu"""

      self._test_attention_slicing_forward_pass(test_max_difference=__lowerCAmelCase					)


    def      lowerCAmelCase_  (					self	:  Any					):
      _UpperCAmelCase						 =      torch_device in ["""cpu""", """mps"""]

      self._test_inference_batch_single_identical(test_max_difference=__lowerCAmelCase					)



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


    def      lowerCAmelCase_  (					self	:  List[str]					):
      # clean up the VRAM after each test
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()


    def      lowerCAmelCase_  (					self	:  List[str]					):
      _UpperCAmelCase						 =      load_numpy(
          """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"""					)

      _UpperCAmelCase						 =      StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""   ,				torch_dtype=torch.floataa					)
      pipe.to(__lowerCAmelCase					)
      pipe.set_progress_bar_config(disable=__lowerCAmelCase					)
      # stable unclip will oom when integration tests are run on a V100,
      # so turn on memory savings
      pipe.enable_attention_slicing()
      pipe.enable_sequential_cpu_offload()

      _UpperCAmelCase						 =      torch.Generator(device="""cpu"""					).manual_seed(0					)
      _UpperCAmelCase						 =      pipe("""anime turle"""   ,				generator=__lowerCAmelCase   ,				output_type="""np"""					)

      _UpperCAmelCase						 =      output.images[0]

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

      assert_mean_pixel_difference(__lowerCAmelCase   ,				__lowerCAmelCase					)


    def      lowerCAmelCase_  (					self	:  List[str]					):
      torch.cuda.empty_cache()
      torch.cuda.reset_max_memory_allocated()
      torch.cuda.reset_peak_memory_stats()

      _UpperCAmelCase						 =      StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""   ,				torch_dtype=torch.floataa					)
      _UpperCAmelCase						 =      pipe.to(__lowerCAmelCase					)
      pipe.set_progress_bar_config(disable=__lowerCAmelCase					)
      pipe.enable_attention_slicing()
      pipe.enable_sequential_cpu_offload()

      _UpperCAmelCase						 =      pipe(
          """anime turtle"""   ,				prior_num_inference_steps=2   ,				num_inference_steps=2   ,				output_type="""np"""   ,				)

      _UpperCAmelCase						 =      torch.cuda.max_memory_allocated()
      # make sure that less than 7 GB is allocated
      assert mem_bytes < 7 * 10**9
