





'''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__				(		lowerCAmelCase  ):





						"""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 			UpperCAmelCase					(      nn.Module       ):




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




												def     lowercase__   (      self      :			Optional[Any]      ,      __snake_case      :			Union[str, Any]      ,      *__snake_case      :			Optional[int]      ,      **__snake_case      :			Optional[Any]  )    ->				Dict:
																		return self.module(__snake_case      ,      *__snake_case      ,      **__snake_case  ) + self.adapter(__snake_case  )




@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class 			UpperCAmelCase					(      unittest.TestCase       ):
						# We keep the constants inside the init function and model loading inside setUp function

						# We need to test on relatively large models (aka >1b parameters otherwise the quantiztion may not work as expected)
						# Therefore here we use only bloom-1b3 to test our module
						_lowercase:      Optional[int]											=       '''bigscience/bloom-1b7'''

						# Constant values
						_lowercase:      Union[str, Any]											=       2.109659552692574

						_lowercase:      Union[str, Any]											=       '''Hello my name is'''
						_lowercase:      List[Any]											=       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'''       )
						_lowercase:      int											=       10




						def     lowercase__   (      self      :			str  )    ->				Optional[Any]:
												# Models and tokenizer
												_lowerCAmelCase												=							AutoTokenizer.from_pretrained(self.model_name  )




class 			UpperCAmelCase					(      snake_case_       ):




						def     lowercase__   (      self      :			Optional[int]  )    ->				List[str]:
												super().setUp()

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




						def     lowercase__   (      self      :			List[str]  )    ->				Tuple:
												del self.model_fpaa
												del self.model_abit

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




						def     lowercase__   (      self      :			Dict  )    ->				int:
												_lowerCAmelCase												=							self.model_abit.config

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

												_lowerCAmelCase												=							config.to_dict()
												_lowerCAmelCase												=							config.to_diff_dict()

												_lowerCAmelCase												=							config.to_json_string()




						def     lowercase__   (      self      :			Optional[Any]  )    ->				List[Any]:
												from bitsandbytes.nn import Paramsabit

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

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




						def     lowercase__   (      self      :			Dict  )    ->				Union[str, Any]:
												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(__snake_case      ,      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     lowercase__   (      self      :			Union[str, Any]  )    ->				str:
												_lowerCAmelCase												=							self.tokenizer(self.input_text      ,      return_tensors="""pt"""  )
												_lowerCAmelCase												=							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=__snake_case  )      ,      self.EXPECTED_OUTPUTS  )




						def     lowercase__   (      self      :			Union[str, Any]  )    ->				Optional[int]:
												_lowerCAmelCase												=							BitsAndBytesConfig()
												_lowerCAmelCase												=							True

												_lowerCAmelCase												=							AutoModelForCausalLM.from_pretrained(
												    self.model_name      ,      quantization_config=__snake_case      ,      device_map="""auto"""  )

												_lowerCAmelCase												=							self.tokenizer(self.input_text      ,      return_tensors="""pt"""  )
												_lowerCAmelCase												=							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=__snake_case  )      ,      self.EXPECTED_OUTPUTS  )




						def     lowercase__   (      self      :			Tuple  )    ->				List[str]:
												with self.assertRaises(__snake_case  ), tempfile.TemporaryDirectory() as tmpdirname:
																		self.model_abit.save_pretrained(__snake_case  )




						def     lowercase__   (      self      :			Union[str, Any]  )    ->				Union[str, Any]:
												_lowerCAmelCase												=							BitsAndBytesConfig()

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




						def     lowercase__   (      self      :			Any  )    ->				Dict:
												with self.assertRaises(__snake_case  ):
																		# Tries with `str`
																		self.model_abit.to("""cpu"""  )

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

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

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

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

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

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

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

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

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




						def     lowercase__   (      self      :			List[str]  )    ->				Dict:
												_lowerCAmelCase												=							AutoModelForSeqaSeqLM.from_pretrained("""t5-small"""      ,      load_in_abit=__snake_case      ,      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 			UpperCAmelCase					(      unittest.TestCase       ):




						@classmethod
						def     lowercase__   (      cls      :			Optional[int]  )    ->				Optional[Any]:
												_lowerCAmelCase												=							"""t5-small"""
												_lowerCAmelCase												=							"""google/flan-t5-small"""  # flan-t5 uses dense-act instead of dense-relu-dense
												_lowerCAmelCase												=							AutoTokenizer.from_pretrained(cls.model_name  )
												_lowerCAmelCase												=							"""Translate in German: Hello, my dog is cute"""




						def     lowercase__   (      self      :			Any  )    ->				List[str]:
												gc.collect()
												torch.cuda.empty_cache()




						def     lowercase__   (      self      :			str  )    ->				Dict:
												from transformers import TaForConditionalGeneration

												_lowerCAmelCase												=							TaForConditionalGeneration._keep_in_fpaa_modules
												_lowerCAmelCase												=							None

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

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




						def     lowercase__   (      self      :			Optional[int]  )    ->				List[Any]:
												import bitsandbytes as bnb

												from transformers import TaForConditionalGeneration

												# test with `t5-small`
												_lowerCAmelCase												=							TaForConditionalGeneration.from_pretrained(self.model_name      ,      load_in_abit=__snake_case      ,      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  )  )

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

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




class 			UpperCAmelCase					(      snake_case_       ):




						def     lowercase__   (      self      :			Optional[Any]  )    ->				List[Any]:
												super().setUp()
												# model_name
												_lowerCAmelCase												=							"""bigscience/bloom-560m"""
												_lowerCAmelCase												=							"""t5-small"""

												# Different types of model

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




						def     lowercase__   (      self      :			Optional[Any]  )    ->				Optional[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     lowercase__   (      self      :			str  )    ->				Optional[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 			UpperCAmelCase					(      snake_case_       ):




						def     lowercase__   (      self      :			List[Any]  )    ->				Dict:
												super().setUp()




						def     lowercase__   (      self      :			Union[str, Any]  )    ->				Union[str, Any]:
												del self.pipe

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




						def     lowercase__   (      self      :			Union[str, Any]  )    ->				int:
												_lowerCAmelCase												=							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
												_lowerCAmelCase												=							self.pipe(self.input_text  )
												self.assertIn(pipeline_output[0]["""generated_text"""]      ,      self.EXPECTED_OUTPUTS  )




@require_torch_multi_gpu
class 			UpperCAmelCase					(      snake_case_       ):




						def     lowercase__   (      self      :			int  )    ->				Union[str, Any]:
												super().setUp()




						def     lowercase__   (      self      :			Union[str, Any]  )    ->				List[str]:
												_lowerCAmelCase												=							AutoModelForCausalLM.from_pretrained(
												    self.model_name      ,      load_in_abit=__snake_case      ,      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
												_lowerCAmelCase												=							self.tokenizer(self.input_text      ,      return_tensors="""pt"""  )

												# Second real batch
												_lowerCAmelCase												=							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=__snake_case  )      ,      self.EXPECTED_OUTPUTS  )




class 			UpperCAmelCase					(      snake_case_       ):




						def     lowercase__   (      self      :			Tuple  )    ->				Union[str, Any]:
												_lowerCAmelCase												=							"""facebook/opt-350m"""
												super().setUp()




						def     lowercase__   (      self      :			Optional[Any]  )    ->				Dict:
												if version.parse(importlib.metadata.version("""bitsandbytes"""  )  ) < version.parse("""0.37.0"""  ):
																		return

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

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

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

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

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

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

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




class 			UpperCAmelCase					(      snake_case_       ):
						_lowercase:      Optional[Any]											=       '''gpt2-xl'''
						_lowercase:      Tuple											=       3.3191854854152187













'''simple docstring'''






import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizer

from diffusers import (
    AltDiffusionImgaImgPipeline,
    AutoencoderKL,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()




class 			UpperCAmelCase					(      unittest.TestCase       ):




      def     lowercase__   (      self      :			Optional[int]  )    ->				Dict:
            # clean up the VRAM after each test
            super().tearDown()
            gc.collect()
            torch.cuda.empty_cache()




      @property
      def     lowercase__   (      self      :			List[Any]  )    ->				List[str]:
            _lowerCAmelCase												=							1
            _lowerCAmelCase												=							3
            _lowerCAmelCase												=							(32, 32)

            _lowerCAmelCase												=							floats_tensor((batch_size, num_channels) + sizes      ,      rng=random.Random(0  )  ).to(__snake_case  )
            return image




      @property
      def     lowercase__   (      self      :			int  )    ->				Union[str, Any]:
            torch.manual_seed(0  )
            _lowerCAmelCase												=							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      ,      )
            return model




      @property
      def     lowercase__   (      self      :			Optional[int]  )    ->				List[str]:
            torch.manual_seed(0  )
            _lowerCAmelCase												=							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      ,      )
            return model




      @property
      def     lowercase__   (      self      :			Dict  )    ->				Optional[Any]:
            torch.manual_seed(0  )
            _lowerCAmelCase												=							RobertaSeriesConfig(
                hidden_size=32      ,      project_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=50_06      ,      )
            return RobertaSeriesModelWithTransformation(__snake_case  )




      @property
      def     lowercase__   (      self      :			Union[str, Any]  )    ->				str:
            def extract(*__snake_case      :			List[Any]      ,      **__snake_case      :			Any  ):




                  class 			UpperCAmelCase					:




                        def __init__(      self      :			Any  )    ->				Any:
                              _lowerCAmelCase												=							torch.ones([0]  )




                        def     lowercase__   (      self      :			Optional[Any]      ,      __snake_case      :			Tuple  )    ->				Dict:
                              self.pixel_values.to(__snake_case  )
                              return self




                  return Out()

            return extract




      def     lowercase__   (      self      :			List[str]  )    ->				Optional[int]:
            _lowerCAmelCase												=							"""cpu"""  # ensure determinism for the device-dependent torch.Generator
            _lowerCAmelCase												=							self.dummy_cond_unet
            _lowerCAmelCase												=							PNDMScheduler(skip_prk_steps=__snake_case  )
            _lowerCAmelCase												=							self.dummy_vae
            _lowerCAmelCase												=							self.dummy_text_encoder
            _lowerCAmelCase												=							XLMRobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-xlm-roberta"""  )
            _lowerCAmelCase												=							77

            _lowerCAmelCase												=							self.dummy_image.to(__snake_case  )
            _lowerCAmelCase												=							init_image / 2 + 0.5

            # make sure here that pndm scheduler skips prk
            _lowerCAmelCase												=							AltDiffusionImgaImgPipeline(
                unet=__snake_case      ,      scheduler=__snake_case      ,      vae=__snake_case      ,      text_encoder=__snake_case      ,      tokenizer=__snake_case      ,      safety_checker=__snake_case      ,      feature_extractor=self.dummy_extractor      ,      )
            _lowerCAmelCase												=							VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor      ,      do_normalize=__snake_case  )
            _lowerCAmelCase												=							alt_pipe.to(__snake_case  )
            alt_pipe.set_progress_bar_config(disable=__snake_case  )

            _lowerCAmelCase												=							"""A painting of a squirrel eating a burger"""
            _lowerCAmelCase												=							torch.Generator(device=__snake_case  ).manual_seed(0  )
            _lowerCAmelCase												=							alt_pipe(
                [prompt]      ,      generator=__snake_case      ,      guidance_scale=6.0      ,      num_inference_steps=2      ,      output_type="""np"""      ,      image=__snake_case      ,      )

            _lowerCAmelCase												=							output.images

            _lowerCAmelCase												=							torch.Generator(device=__snake_case  ).manual_seed(0  )
            _lowerCAmelCase												=							alt_pipe(
                [prompt]      ,      generator=__snake_case      ,      guidance_scale=6.0      ,      num_inference_steps=2      ,      output_type="""np"""      ,      image=__snake_case      ,      return_dict=__snake_case      ,      )[0]

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

            assert image.shape == (1, 32, 32, 3)
            _lowerCAmelCase												=							np.array([0.44_27, 0.37_31, 0.42_49, 0.49_41, 0.45_46, 0.41_48, 0.41_93, 0.46_66, 0.44_99]  )

            assert np.abs(image_slice.flatten() - expected_slice  ).max() < 5E-3
            assert np.abs(image_from_tuple_slice.flatten() - expected_slice  ).max() < 5E-3




      @unittest.skipIf(torch_device != """cuda"""      ,      """This test requires a GPU"""  )
      def     lowercase__   (      self      :			Tuple  )    ->				str:
            _lowerCAmelCase												=							self.dummy_cond_unet
            _lowerCAmelCase												=							PNDMScheduler(skip_prk_steps=__snake_case  )
            _lowerCAmelCase												=							self.dummy_vae
            _lowerCAmelCase												=							self.dummy_text_encoder
            _lowerCAmelCase												=							XLMRobertaTokenizer.from_pretrained("""hf-internal-testing/tiny-xlm-roberta"""  )
            _lowerCAmelCase												=							77

            _lowerCAmelCase												=							self.dummy_image.to(__snake_case  )

            # put models in fp16
            _lowerCAmelCase												=							unet.half()
            _lowerCAmelCase												=							vae.half()
            _lowerCAmelCase												=							bert.half()

            # make sure here that pndm scheduler skips prk
            _lowerCAmelCase												=							AltDiffusionImgaImgPipeline(
                unet=__snake_case      ,      scheduler=__snake_case      ,      vae=__snake_case      ,      text_encoder=__snake_case      ,      tokenizer=__snake_case      ,      safety_checker=__snake_case      ,      feature_extractor=self.dummy_extractor      ,      )
            _lowerCAmelCase												=							VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor      ,      do_normalize=__snake_case  )
            _lowerCAmelCase												=							alt_pipe.to(__snake_case  )
            alt_pipe.set_progress_bar_config(disable=__snake_case  )

            _lowerCAmelCase												=							"""A painting of a squirrel eating a burger"""
            _lowerCAmelCase												=							torch.manual_seed(0  )
            _lowerCAmelCase												=							alt_pipe(
                [prompt]      ,      generator=__snake_case      ,      num_inference_steps=2      ,      output_type="""np"""      ,      image=__snake_case      ,      ).images

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




      @unittest.skipIf(torch_device != """cuda"""      ,      """This test requires a GPU"""  )
      def     lowercase__   (      self      :			Optional[Any]  )    ->				Optional[Any]:
            _lowerCAmelCase												=							load_image(
                """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
                """/img2img/sketch-mountains-input.jpg"""  )
            # resize to resolution that is divisible by 8 but not 16 or 32
            _lowerCAmelCase												=							init_image.resize((7_60, 5_04)  )

            _lowerCAmelCase												=							"""BAAI/AltDiffusion"""
            _lowerCAmelCase												=							AltDiffusionImgaImgPipeline.from_pretrained(
                __snake_case      ,      safety_checker=__snake_case      ,      )
            pipe.to(__snake_case  )
            pipe.set_progress_bar_config(disable=__snake_case  )
            pipe.enable_attention_slicing()

            _lowerCAmelCase												=							"""A fantasy landscape, trending on artstation"""

            _lowerCAmelCase												=							torch.manual_seed(0  )
            _lowerCAmelCase												=							pipe(
                prompt=__snake_case      ,      image=__snake_case      ,      strength=0.75      ,      guidance_scale=7.5      ,      generator=__snake_case      ,      output_type="""np"""      ,      )
            _lowerCAmelCase												=							output.images[0]

            _lowerCAmelCase												=							image[2_55:2_58, 3_83:3_86, -1]

            assert image.shape == (5_04, 7_60, 3)
            _lowerCAmelCase												=							np.array([0.93_58, 0.93_97, 0.95_99, 0.99_01, 1.00_00, 1.00_00, 0.98_82, 1.00_00, 1.00_00]  )

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




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




      def     lowercase__   (      self      :			int  )    ->				Any:
            # clean up the VRAM after each test
            super().tearDown()
            gc.collect()
            torch.cuda.empty_cache()




      def     lowercase__   (      self      :			Dict  )    ->				Tuple:
            _lowerCAmelCase												=							load_image(
                """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
                """/img2img/sketch-mountains-input.jpg"""  )
            _lowerCAmelCase												=							init_image.resize((7_68, 5_12)  )
            _lowerCAmelCase												=							load_numpy(
                """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy"""  )

            _lowerCAmelCase												=							"""BAAI/AltDiffusion"""
            _lowerCAmelCase												=							AltDiffusionImgaImgPipeline.from_pretrained(
                __snake_case      ,      safety_checker=__snake_case      ,      )
            pipe.to(__snake_case  )
            pipe.set_progress_bar_config(disable=__snake_case  )
            pipe.enable_attention_slicing()

            _lowerCAmelCase												=							"""A fantasy landscape, trending on artstation"""

            _lowerCAmelCase												=							torch.manual_seed(0  )
            _lowerCAmelCase												=							pipe(
                prompt=__snake_case      ,      image=__snake_case      ,      strength=0.75      ,      guidance_scale=7.5      ,      generator=__snake_case      ,      output_type="""np"""      ,      )
            _lowerCAmelCase												=							output.images[0]

            assert image.shape == (5_12, 7_68, 3)
            # img2img is flaky across GPUs even in fp32, so using MAE here
            assert np.abs(expected_image - image  ).max() < 1E-2






