


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 A  (   unittest.TestCase     ):






      def        lowerCamelCase       (					self						:     Optional[Any] )					->						str:
             """simple docstring"""




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






      @property
      def        lowerCamelCase       (					self						:     Optional[int] )					->						Optional[Any]:
             """simple docstring"""




             _lowerCamelCase       :		Optional[int]		=1
             _lowerCamelCase       :		List[str]		=3
             _lowerCamelCase       :		int		=(32, 32)

             _lowerCamelCase       :		Optional[Any]		=floats_tensor((batch_size, num_channels) + sizes			,   rng=random.Random(0 ) ).to(lowercase_ )
             return image






      @property
      def        lowerCamelCase       (					self						:     Tuple )					->						int:
             """simple docstring"""




             torch.manual_seed(0 )
             _lowerCamelCase       :		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			,   )
             return model






      @property
      def        lowerCamelCase       (					self						:     List[str] )					->						Union[str, Any]:
             """simple docstring"""




             torch.manual_seed(0 )
             _lowerCamelCase       :		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			,   )
             return model






      @property
      def        lowerCamelCase       (					self						:     Dict )					->						str:
             """simple docstring"""




             torch.manual_seed(0 )
             _lowerCamelCase       :		Dict		=RobertaSeriesConfig(
                 hidden_size=32			,   project_dim=32			,   intermediate_size=37			,   layer_norm_eps=1E-05			,   num_attention_heads=4			,   num_hidden_layers=5			,   pad_token_id=1			,   vocab_size=5006			,   )
             return RobertaSeriesModelWithTransformation(lowercase_ )






      @property
      def        lowerCamelCase       (					self						:     Dict )					->						List[Any]:
             """simple docstring"""




             def extract(*lowercase_						:     Dict			,   **lowercase_						:     Tuple ):




                    class A  :






                          def __init__(					self						:     Any )					->						int:
                                 """simple docstring"""




                                 _lowerCamelCase       :		Union[str, Any]		=torch.ones([0] )






                          def        lowerCamelCase       (					self						:     List[Any]			,   lowercase_						:     Optional[int] )					->						Any:
                                 """simple docstring"""




                                 self.pixel_values.to(lowercase_ )
                                 return self




                    return Out()

             return extract






      def        lowerCamelCase       (					self						:     Any )					->						List[str]:
             """simple docstring"""




             _lowerCamelCase       :		Optional[Any]		='cpu'  # ensure determinism for the device-dependent torch.Generator
             _lowerCamelCase       :		Dict		=self.dummy_cond_unet
             _lowerCamelCase       :		Tuple		=PNDMScheduler(skip_prk_steps=lowercase_ )
             _lowerCamelCase       :		Tuple		=self.dummy_vae
             _lowerCamelCase       :		int		=self.dummy_text_encoder
             _lowerCamelCase       :		Tuple		=XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta' )
             _lowerCamelCase       :		Union[str, Any]		=77

             _lowerCamelCase       :		str		=self.dummy_image.to(lowercase_ )
             _lowerCamelCase       :		str		=init_image / 2 + 0.5

             # make sure here that pndm scheduler skips prk
             _lowerCamelCase       :		str		=AltDiffusionImgaImgPipeline(
                 unet=lowercase_			,   scheduler=lowercase_			,   vae=lowercase_			,   text_encoder=lowercase_			,   tokenizer=lowercase_			,   safety_checker=lowercase_			,   feature_extractor=self.dummy_extractor			,   )
             _lowerCamelCase       :		Any		=VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor			,   do_normalize=lowercase_ )
             _lowerCamelCase       :		Optional[Any]		=alt_pipe.to(lowercase_ )
             alt_pipe.set_progress_bar_config(disable=lowercase_ )

             _lowerCamelCase       :		List[str]		='A painting of a squirrel eating a burger'
             _lowerCamelCase       :		List[Any]		=torch.Generator(device=lowercase_ ).manual_seed(0 )
             _lowerCamelCase       :		str		=alt_pipe(
                 [prompt]			,   generator=lowercase_			,   guidance_scale=6.0			,   num_inference_steps=2			,   output_type='np'			,   image=lowercase_			,   )

             _lowerCamelCase       :		List[Any]		=output.images

             _lowerCamelCase       :		Dict		=torch.Generator(device=lowercase_ ).manual_seed(0 )
             _lowerCamelCase       :		Dict		=alt_pipe(
                 [prompt]			,   generator=lowercase_			,   guidance_scale=6.0			,   num_inference_steps=2			,   output_type='np'			,   image=lowercase_			,   return_dict=lowercase_			,   )[0]

             _lowerCamelCase       :		Dict		=image[0, -3:, -3:, -1]
             _lowerCamelCase       :		List[Any]		=image_from_tuple[0, -3:, -3:, -1]

             assert image.shape == (1, 32, 32, 3)
             _lowerCamelCase       :		int		=np.array([0.4427, 0.3731, 0.4249, 0.4941, 0.4546, 0.4148, 0.4193, 0.4666, 0.4499] )

             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        lowerCamelCase       (					self						:     Optional[int] )					->						Dict:
             """simple docstring"""




             _lowerCamelCase       :		Optional[Any]		=self.dummy_cond_unet
             _lowerCamelCase       :		Union[str, Any]		=PNDMScheduler(skip_prk_steps=lowercase_ )
             _lowerCamelCase       :		Optional[Any]		=self.dummy_vae
             _lowerCamelCase       :		str		=self.dummy_text_encoder
             _lowerCamelCase       :		Optional[int]		=XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta' )
             _lowerCamelCase       :		int		=77

             _lowerCamelCase       :		Dict		=self.dummy_image.to(lowercase_ )

             # put models in fp16
             _lowerCamelCase       :		List[Any]		=unet.half()
             _lowerCamelCase       :		Any		=vae.half()
             _lowerCamelCase       :		Dict		=bert.half()

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

             _lowerCamelCase       :		Optional[int]		='A painting of a squirrel eating a burger'
             _lowerCamelCase       :		List[str]		=torch.manual_seed(0 )
             _lowerCamelCase       :		Union[str, Any]		=alt_pipe(
                 [prompt]			,   generator=lowercase_			,   num_inference_steps=2			,   output_type='np'			,   image=lowercase_			,   ).images

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






      @unittest.skipIf(torch_device != 'cuda'			,   'This test requires a GPU' )
      def        lowerCamelCase       (					self						:     List[str] )					->						List[Any]:
             """simple docstring"""




             _lowerCamelCase       :		Union[str, Any]		=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       :		Tuple		=init_image.resize((760, 504) )

             _lowerCamelCase       :		str		='BAAI/AltDiffusion'
             _lowerCamelCase       :		Union[str, Any]		=AltDiffusionImgaImgPipeline.from_pretrained(
                 lowercase_			,   safety_checker=lowercase_			,   )
             pipe.to(lowercase_ )
             pipe.set_progress_bar_config(disable=lowercase_ )
             pipe.enable_attention_slicing()

             _lowerCamelCase       :		Optional[Any]		='A fantasy landscape, trending on artstation'

             _lowerCamelCase       :		Optional[int]		=torch.manual_seed(0 )
             _lowerCamelCase       :		Tuple		=pipe(
                 prompt=lowercase_			,   image=lowercase_			,   strength=0.75			,   guidance_scale=7.5			,   generator=lowercase_			,   output_type='np'			,   )
             _lowerCamelCase       :		Union[str, Any]		=output.images[0]

             _lowerCamelCase       :		int		=image[255:258, 383:386, -1]

             assert image.shape == (504, 760, 3)
             _lowerCamelCase       :		List[str]		=np.array([0.9358, 0.9397, 0.9599, 0.9901, 1.0000, 1.0000, 0.9882, 1.0000, 1.0000] )

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




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






      def        lowerCamelCase       (					self						:     List[Any] )					->						Any:
             """simple docstring"""




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






      def        lowerCamelCase       (					self						:     Optional[int] )					->						Optional[int]:
             """simple docstring"""




             _lowerCamelCase       :		int		=load_image(
                 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
                 '/img2img/sketch-mountains-input.jpg' )
             _lowerCamelCase       :		str		=init_image.resize((768, 512) )
             _lowerCamelCase       :		Optional[Any]		=load_numpy(
                 'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy' )

             _lowerCamelCase       :		Optional[Any]		='BAAI/AltDiffusion'
             _lowerCamelCase       :		str		=AltDiffusionImgaImgPipeline.from_pretrained(
                 lowercase_			,   safety_checker=lowercase_			,   )
             pipe.to(lowercase_ )
             pipe.set_progress_bar_config(disable=lowercase_ )
             pipe.enable_attention_slicing()

             _lowerCamelCase       :		Tuple		='A fantasy landscape, trending on artstation'

             _lowerCamelCase       :		int		=torch.manual_seed(0 )
             _lowerCamelCase       :		Tuple		=pipe(
                 prompt=lowercase_			,   image=lowercase_			,   strength=0.75			,   guidance_scale=7.5			,   generator=lowercase_			,   output_type='np'			,   )
             _lowerCamelCase       :		int		=output.images[0]

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






from __future__ import annotations

import unittest

from transformers import XGLMConfig, XGLMTokenizer, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers.models.xglm.modeling_tf_xglm import (
     TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
     TFXGLMForCausalLM,
     TFXGLMModel,
 )




@require_tf
class A  :
      UpperCamelCase__							:  Union[str, Any]      =XGLMConfig
      UpperCamelCase__							:  Dict      ={}
      UpperCamelCase__							:  Tuple      ='gelu'






      def __init__(					self						:     List[Any]			,   lowercase_						:     List[str]			,   lowercase_						:     Union[str, Any]=14			,   lowercase_						:     Dict=7			,   lowercase_						:     Union[str, Any]=True			,   lowercase_						:     Optional[Any]=True			,   lowercase_						:     Any=True			,   lowercase_						:     Optional[int]=99			,   lowercase_						:     List[Any]=32			,   lowercase_						:     List[Any]=2			,   lowercase_						:     Dict=4			,   lowercase_						:     List[str]=37			,   lowercase_						:     int="gelu"			,   lowercase_						:     List[Any]=0.1			,   lowercase_						:     Union[str, Any]=0.1			,   lowercase_						:     List[str]=512			,   lowercase_						:     Union[str, Any]=0.02			,   )					->						Optional[Any]:
             """simple docstring"""




             _lowerCamelCase       :		Dict		=parent
             _lowerCamelCase       :		Optional[Any]		=batch_size
             _lowerCamelCase       :		Optional[int]		=seq_length
             _lowerCamelCase       :		Union[str, Any]		=is_training
             _lowerCamelCase       :		Tuple		=use_input_mask
             _lowerCamelCase       :		str		=use_labels
             _lowerCamelCase       :		Any		=vocab_size
             _lowerCamelCase       :		List[str]		=d_model
             _lowerCamelCase       :		List[Any]		=num_hidden_layers
             _lowerCamelCase       :		Union[str, Any]		=num_attention_heads
             _lowerCamelCase       :		List[Any]		=ffn_dim
             _lowerCamelCase       :		Optional[Any]		=activation_function
             _lowerCamelCase       :		Dict		=activation_dropout
             _lowerCamelCase       :		Tuple		=attention_dropout
             _lowerCamelCase       :		List[str]		=max_position_embeddings
             _lowerCamelCase       :		int		=initializer_range
             _lowerCamelCase       :		Optional[int]		=None
             _lowerCamelCase       :		Optional[Any]		=0
             _lowerCamelCase       :		List[str]		=2
             _lowerCamelCase       :		Any		=1






      def        lowerCamelCase       (					self						:     str )					->						int:
             """simple docstring"""




             return XGLMConfig.from_pretrained('facebook/xglm-564M' )






      def        lowerCamelCase       (					self						:     List[Any] )					->						Tuple:
             """simple docstring"""




             _lowerCamelCase       :		Union[str, Any]		=tf.clip_by_value(
                 ids_tensor([self.batch_size, self.seq_length]			,   self.vocab_size )			,   clip_value_min=0			,   clip_value_max=3 )

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

             _lowerCamelCase       :		Optional[int]		=self.get_config()

             _lowerCamelCase       :		Optional[Any]		=floats_tensor([self.num_hidden_layers, self.num_attention_heads]			,   2 )

             return (
                 config,
                 input_ids,
                 input_mask,
                 head_mask,
             )






      def        lowerCamelCase       (					self						:     List[str] )					->						Dict:
             """simple docstring"""




             return XGLMConfig(
                 vocab_size=self.vocab_size			,   d_model=self.hidden_size			,   num_layers=self.num_hidden_layers			,   attention_heads=self.num_attention_heads			,   ffn_dim=self.ffn_dim			,   activation_function=self.activation_function			,   activation_dropout=self.activation_dropout			,   attention_dropout=self.attention_dropout			,   max_position_embeddings=self.max_position_embeddings			,   initializer_range=self.initializer_range			,   use_cache=lowercase_			,   bos_token_id=self.bos_token_id			,   eos_token_id=self.eos_token_id			,   pad_token_id=self.pad_token_id			,   return_dict=lowercase_			,   )






      def        lowerCamelCase       (					self						:     Optional[int] )					->						str:
             """simple docstring"""




             _lowerCamelCase       :		str		=self.prepare_config_and_inputs()

             (
                 (
                 _lowerCamelCase
             )	,     (
                 _lowerCamelCase
             )	,     (
                 _lowerCamelCase
             )	,     (
                 _lowerCamelCase
             )	,     
             )       :		Any		=config_and_inputs

             _lowerCamelCase       :		Union[str, Any]		={
                 'input_ids': input_ids,
                 'head_mask': head_mask,
             }

             return config, inputs_dict




@require_tf
class A  (   UpperCamelCase_    ,							UpperCamelCase_    ,							unittest.TestCase     ):
      UpperCamelCase__							:  Union[str, Any]      =(TFXGLMModel, TFXGLMForCausalLM) if is_tf_available() else ()
      UpperCamelCase__							:  List[str]      =(TFXGLMForCausalLM,) if is_tf_available() else ()
      UpperCamelCase__							:  Any      =(
          {'feature-extraction': TFXGLMModel, 'text-generation': TFXGLMForCausalLM} if is_tf_available() else {}
      )
      UpperCamelCase__							:  str      =False
      UpperCamelCase__							:  int      =False
      UpperCamelCase__							:  int      =False






      def        lowerCamelCase       (					self						:     Optional[int] )					->						List[Any]:
             """simple docstring"""




             _lowerCamelCase       :		Tuple		=TFXGLMModelTester(self )
             _lowerCamelCase       :		str		=ConfigTester(self			,   config_class=lowercase_			,   n_embd=37 )






      def        lowerCamelCase       (					self						:     str )					->						Dict:
             """simple docstring"""




             self.config_tester.run_common_tests()






      @slow
      def        lowerCamelCase       (					self						:     Any )					->						int:
             """simple docstring"""




             for model_name in TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    _lowerCamelCase       :		int		=TFXGLMModel.from_pretrained(lowercase_ )
                    self.assertIsNotNone(lowercase_ )






      @unittest.skip(reason='Currently, model embeddings are going to undergo a major refactor.' )
      def        lowerCamelCase       (					self						:     Optional[int] )					->						str:
             """simple docstring"""




             super().test_resize_token_embeddings()




@require_tf
class A  (   unittest.TestCase     ):






      @slow
      def        lowerCamelCase       (					self						:     str			,   lowercase_						:     str=True )					->						Tuple:
             """simple docstring"""




             _lowerCamelCase       :		Any		=TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M' )
             _lowerCamelCase       :		List[Any]		=tf.convert_to_tensor([[2, 268, 9865]]			,   dtype=tf.intaa )  # The dog
             # </s> The dog is a very friendly dog. He is very affectionate and loves to play with other
             # fmt: off
             _lowerCamelCase       :		int		=[2, 268, 9865, 67, 11, 1988, 5_7252, 9865, 5, 984, 67, 1988, 21_3838, 1658, 53, 7_0446, 33, 6657, 278, 1581]
             # fmt: on
             _lowerCamelCase       :		Dict		=model.generate(lowercase_			,   do_sample=lowercase_			,   num_beams=1 )
             if verify_outputs:
                    self.assertListEqual(output_ids[0].numpy().tolist()			,   lowercase_ )






      @slow
      def        lowerCamelCase       (					self						:     List[Any] )					->						Union[str, Any]:
             """simple docstring"""




             _lowerCamelCase       :		List[str]		=XGLMTokenizer.from_pretrained('facebook/xglm-564M' )
             _lowerCamelCase       :		Any		=TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M' )

             tf.random.set_seed(0 )
             _lowerCamelCase       :		Tuple		=tokenizer('Today is a nice day and'			,   return_tensors='tf' )
             _lowerCamelCase       :		Optional[int]		=tokenized.input_ids
             # forces the generation to happen on CPU, to avoid GPU-related quirks (and assure same output regardless of the available devices)
             with tf.device(':/CPU:0' ):
                    _lowerCamelCase       :		List[Any]		=model.generate(lowercase_			,   do_sample=lowercase_			,   seed=[7, 0] )
             _lowerCamelCase       :		Union[str, Any]		=tokenizer.decode(output_ids[0]			,   skip_special_tokens=lowercase_ )

             _lowerCamelCase       :		Union[str, Any]		=(
                 'Today is a nice day and warm evening here over Southern Alberta!! Today when they closed schools due'
             )
             self.assertEqual(lowercase_			,   lowercase_ )






      @slow
      def        lowerCamelCase       (					self						:     Union[str, Any] )					->						Union[str, Any]:
             """simple docstring"""




             _lowerCamelCase       :		int		=TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M' )
             _lowerCamelCase       :		Any		=XGLMTokenizer.from_pretrained('facebook/xglm-564M' )

             _lowerCamelCase       :		Optional[Any]		='left'

             # use different length sentences to test batching
             _lowerCamelCase       :		int		=[
                 'This is an extremelly long sentence that only exists to test the ability of the model to cope with '
                 'left-padding, such as in batched generation. The output for the sequence below should be the same '
                 'regardless of whether left padding is applied or not. When',
                 'Hello, my dog is a little',
             ]

             _lowerCamelCase       :		List[Any]		=tokenizer(lowercase_			,   return_tensors='tf'			,   padding=lowercase_ )
             _lowerCamelCase       :		int		=inputs['input_ids']

             _lowerCamelCase       :		str		=model.generate(input_ids=lowercase_			,   attention_mask=inputs['attention_mask']			,   max_new_tokens=12 )

             _lowerCamelCase       :		Optional[Any]		=tokenizer(sentences[0]			,   return_tensors='tf' ).input_ids
             _lowerCamelCase       :		List[str]		=model.generate(input_ids=lowercase_			,   max_new_tokens=12 )

             _lowerCamelCase       :		Tuple		=tokenizer(sentences[1]			,   return_tensors='tf' ).input_ids
             _lowerCamelCase       :		Dict		=model.generate(input_ids=lowercase_			,   max_new_tokens=12 )

             _lowerCamelCase       :		str		=tokenizer.batch_decode(lowercase_			,   skip_special_tokens=lowercase_ )
             _lowerCamelCase       :		str		=tokenizer.decode(output_non_padded[0]			,   skip_special_tokens=lowercase_ )
             _lowerCamelCase       :		int		=tokenizer.decode(output_padded[0]			,   skip_special_tokens=lowercase_ )

             _lowerCamelCase       :		List[str]		=[
                 'This is an extremelly long sentence that only exists to test the ability of the model to cope with '
                 'left-padding, such as in batched generation. The output for the sequence below should be the same '
                 'regardless of whether left padding is applied or not. When left padding is applied, the sequence will be '
                 'a single',
                 'Hello, my dog is a little bit of a shy one, but he is very friendly',
             ]
             self.assertListEqual(lowercase_			,   lowercase_ )
             self.assertListEqual(lowercase_			,   [non_padded_sentence, padded_sentence] )


