
# This model implementation is heavily inspired by https://github.com/haofanwang/ControlNet-for-Diffusers/

import gc
import random
import tempfile
import unittest

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

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()




class 						lowercase__  (						UpperCamelCase_     ,       UpperCamelCase_     ,       UpperCamelCase_     ,       unittest.TestCase  ):
	A__    :   List[str]				       =StableDiffusionControlNetImgaImgPipeline
	A__    :   Optional[Any]				       =TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'height', 'width'}
	A__    :   Any				       =TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
	A__    :   Optional[int]				       =IMAGE_TO_IMAGE_IMAGE_PARAMS.union({"""control_image"""}  )
	A__    :   Any				       =IMAGE_TO_IMAGE_IMAGE_PARAMS
	def      A_				(			self							:   Tuple							):
						torch.manual_seed(0							)
						SCREAMING_SNAKE_CASE__													= 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       ,   )
						torch.manual_seed(0							)
						SCREAMING_SNAKE_CASE__													= ControlNetModel(
						    block_out_channels=(32, 64)       ,   layers_per_block=2       ,   in_channels=4       ,   down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')       ,   cross_attention_dim=32       ,   conditioning_embedding_out_channels=(16, 32)       ,   )
						torch.manual_seed(0							)
						SCREAMING_SNAKE_CASE__													= DDIMScheduler(
						    beta_start=0.00_085       ,   beta_end=0.012       ,   beta_schedule='scaled_linear'       ,   clip_sample=lowercase_       ,   set_alpha_to_one=lowercase_       ,   )
						torch.manual_seed(0							)
						SCREAMING_SNAKE_CASE__													= 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							)
						SCREAMING_SNAKE_CASE__													= 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       ,   )
						SCREAMING_SNAKE_CASE__													= CLIPTextModel(lowercase_							)
						SCREAMING_SNAKE_CASE__													= CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'							)

						SCREAMING_SNAKE_CASE__													= {
						    'unet': unet,
						    'controlnet': controlnet,
						    'scheduler': scheduler,
						    'vae': vae,
						    'text_encoder': text_encoder,
						    'tokenizer': tokenizer,
						    'safety_checker': None,
						    'feature_extractor': None,
						}
						return components
	def      A_				(			self							:   Dict       ,   UpperCAmelCase_							:   List[Any]       ,   UpperCAmelCase_							:   Optional[Any]=0							):




						if str(lowercase_							).startswith('mps'							):
											SCREAMING_SNAKE_CASE__													= torch.manual_seed(lowercase_							)
						else:
											SCREAMING_SNAKE_CASE__													= torch.Generator(device=lowercase_							).manual_seed(lowercase_							)

						SCREAMING_SNAKE_CASE__													= 2
						SCREAMING_SNAKE_CASE__													= randn_tensor(
						    (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)       ,   generator=lowercase_       ,   device=torch.device(lowercase_							)       ,   )
						SCREAMING_SNAKE_CASE__													= floats_tensor(control_image.shape       ,   rng=random.Random(lowercase_							)							).to(lowercase_							)
						SCREAMING_SNAKE_CASE__													= image.cpu().permute(0       ,   2       ,   3       ,   1							)[0]
						SCREAMING_SNAKE_CASE__													= Image.fromarray(np.uinta(lowercase_							)							).convert('RGB'							).resize((64, 64)							)
						SCREAMING_SNAKE_CASE__													= {
						    'prompt': 'A painting of a squirrel eating a burger',
						    'generator': generator,
						    'num_inference_steps': 2,
						    'guidance_scale': 6.0,
						    'output_type': 'numpy',
						    'image': image,
						    'control_image': control_image,
						}

						return inputs
	def      A_				(			self							:   Optional[int]							):
						return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3							)
	@unittest.skipIf(
	    torch_device != 'cuda' or not is_xformers_available()       ,   reason='XFormers attention is only available with CUDA and `xformers` installed'       ,   )
	def      A_				(			self							:   Optional[int]							):
						self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3							)





	def      A_				(			self							:   List[Any]							):
						self._test_inference_batch_single_identical(expected_max_diff=2e-3							)





class 						lowercase__  (						UpperCamelCase_     ,       UpperCamelCase_     ,       unittest.TestCase  ):
	A__    :   Tuple				       =StableDiffusionControlNetImgaImgPipeline
	A__    :   List[str]				       =TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'height', 'width'}
	A__    :   Optional[Any]				       =TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
	A__    :   Union[str, Any]				       =frozenset([]  )  # TO_DO: add image_params once refactored VaeImageProcessor.preprocess
	def      A_				(			self							:   List[Any]							):
						torch.manual_seed(0							)
						SCREAMING_SNAKE_CASE__													= 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       ,   )
						torch.manual_seed(0							)

						def init_weights(UpperCAmelCase_							:   Optional[int]							):
											if isinstance(lowercase_       ,   torch.nn.Convad							):
																torch.nn.init.normal(m.weight							)
																m.bias.data.fill_(1.0							)

						SCREAMING_SNAKE_CASE__													= ControlNetModel(
						    block_out_channels=(32, 64)       ,   layers_per_block=2       ,   in_channels=4       ,   down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')       ,   cross_attention_dim=32       ,   conditioning_embedding_out_channels=(16, 32)       ,   )
						controlneta.controlnet_down_blocks.apply(lowercase_							)

						torch.manual_seed(0							)
						SCREAMING_SNAKE_CASE__													= ControlNetModel(
						    block_out_channels=(32, 64)       ,   layers_per_block=2       ,   in_channels=4       ,   down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')       ,   cross_attention_dim=32       ,   conditioning_embedding_out_channels=(16, 32)       ,   )
						controlneta.controlnet_down_blocks.apply(lowercase_							)

						torch.manual_seed(0							)
						SCREAMING_SNAKE_CASE__													= DDIMScheduler(
						    beta_start=0.00_085       ,   beta_end=0.012       ,   beta_schedule='scaled_linear'       ,   clip_sample=lowercase_       ,   set_alpha_to_one=lowercase_       ,   )
						torch.manual_seed(0							)
						SCREAMING_SNAKE_CASE__													= 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							)
						SCREAMING_SNAKE_CASE__													= 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       ,   )
						SCREAMING_SNAKE_CASE__													= CLIPTextModel(lowercase_							)
						SCREAMING_SNAKE_CASE__													= CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'							)

						SCREAMING_SNAKE_CASE__													= MultiControlNetModel([controlneta, controlneta]							)

						SCREAMING_SNAKE_CASE__													= {
						    'unet': unet,
						    'controlnet': controlnet,
						    'scheduler': scheduler,
						    'vae': vae,
						    'text_encoder': text_encoder,
						    'tokenizer': tokenizer,
						    'safety_checker': None,
						    'feature_extractor': None,
						}
						return components
	def      A_				(			self							:   Union[str, Any]       ,   UpperCAmelCase_							:   Tuple       ,   UpperCAmelCase_							:   Dict=0							):




						if str(lowercase_							).startswith('mps'							):
											SCREAMING_SNAKE_CASE__													= torch.manual_seed(lowercase_							)
						else:
											SCREAMING_SNAKE_CASE__													= torch.Generator(device=lowercase_							).manual_seed(lowercase_							)

						SCREAMING_SNAKE_CASE__													= 2

						SCREAMING_SNAKE_CASE__													= [
						    randn_tensor(
						        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)       ,   generator=lowercase_       ,   device=torch.device(lowercase_							)       ,   ),
						    randn_tensor(
						        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)       ,   generator=lowercase_       ,   device=torch.device(lowercase_							)       ,   ),
						]

						SCREAMING_SNAKE_CASE__													= floats_tensor(control_image[0].shape       ,   rng=random.Random(lowercase_							)							).to(lowercase_							)
						SCREAMING_SNAKE_CASE__													= image.cpu().permute(0       ,   2       ,   3       ,   1							)[0]
						SCREAMING_SNAKE_CASE__													= Image.fromarray(np.uinta(lowercase_							)							).convert('RGB'							).resize((64, 64)							)
						SCREAMING_SNAKE_CASE__													= {
						    'prompt': 'A painting of a squirrel eating a burger',
						    'generator': generator,
						    'num_inference_steps': 2,
						    'guidance_scale': 6.0,
						    'output_type': 'numpy',
						    'image': image,
						    'control_image': control_image,
						}

						return inputs
	def      A_				(			self							:   Any							):
						SCREAMING_SNAKE_CASE__													= self.get_dummy_components()
						SCREAMING_SNAKE_CASE__													= self.pipeline_class(**lowercase_							)
						pipe.to(lowercase_							)

						SCREAMING_SNAKE_CASE__													= 10.0
						SCREAMING_SNAKE_CASE__													= 4

						SCREAMING_SNAKE_CASE__													= self.get_dummy_inputs(lowercase_							)
						SCREAMING_SNAKE_CASE__													= steps
						SCREAMING_SNAKE_CASE__													= scale
						SCREAMING_SNAKE_CASE__													= pipe(**lowercase_							)[0]

						SCREAMING_SNAKE_CASE__													= self.get_dummy_inputs(lowercase_							)
						SCREAMING_SNAKE_CASE__													= steps
						SCREAMING_SNAKE_CASE__													= scale
						SCREAMING_SNAKE_CASE__													= pipe(**lowercase_       ,   control_guidance_start=0.1       ,   control_guidance_end=0.2							)[0]

						SCREAMING_SNAKE_CASE__													= self.get_dummy_inputs(lowercase_							)
						SCREAMING_SNAKE_CASE__													= steps
						SCREAMING_SNAKE_CASE__													= scale
						SCREAMING_SNAKE_CASE__													= pipe(**lowercase_       ,   control_guidance_start=[0.1, 0.3]       ,   control_guidance_end=[0.2, 0.7]							)[0]

						SCREAMING_SNAKE_CASE__													= self.get_dummy_inputs(lowercase_							)
						SCREAMING_SNAKE_CASE__													= steps
						SCREAMING_SNAKE_CASE__													= scale
						SCREAMING_SNAKE_CASE__													= pipe(**lowercase_       ,   control_guidance_start=0.4       ,   control_guidance_end=[0.5, 0.8]							)[0]

						# make sure that all outputs are different
						assert np.sum(np.abs(output_a - output_a							)							) > 1e-3
						assert np.sum(np.abs(output_a - output_a							)							) > 1e-3
						assert np.sum(np.abs(output_a - output_a							)							) > 1e-3
	def      A_				(			self							:   int							):
						return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3							)
	@unittest.skipIf(
	    torch_device != 'cuda' or not is_xformers_available()       ,   reason='XFormers attention is only available with CUDA and `xformers` installed'       ,   )
	def      A_				(			self							:   Dict							):
						self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3							)
	def      A_				(			self							:   List[str]							):
						self._test_inference_batch_single_identical(expected_max_diff=2e-3							)





	def      A_				(			self							:   Optional[Any]							):
						SCREAMING_SNAKE_CASE__													= self.get_dummy_components()
						SCREAMING_SNAKE_CASE__													= self.pipeline_class(**lowercase_							)
						pipe.to(lowercase_							)
						pipe.set_progress_bar_config(disable=lowercase_							)
						with tempfile.TemporaryDirectory() as tmpdir:
											try:
																# save_pretrained is not implemented for Multi-ControlNet
																pipe.save_pretrained(lowercase_							)
											except NotImplementedError:
																pass





@slow
@require_torch_gpu
class 						lowercase__  (						unittest.TestCase  ):
	def      A_				(			self							:   Tuple							):
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()





	def      A_				(			self							:   List[Any]							):
						SCREAMING_SNAKE_CASE__													= ControlNetModel.from_pretrained('lllyasviel/sd-controlnet-canny'							)

						SCREAMING_SNAKE_CASE__													= StableDiffusionControlNetImgaImgPipeline.from_pretrained(
						    'runwayml/stable-diffusion-v1-5'       ,   safety_checker=lowercase_       ,   controlnet=lowercase_							)
						pipe.enable_model_cpu_offload()
						pipe.set_progress_bar_config(disable=lowercase_							)

						SCREAMING_SNAKE_CASE__													= torch.Generator(device='cpu'							).manual_seed(0							)
						SCREAMING_SNAKE_CASE__													= 'evil space-punk bird'
						SCREAMING_SNAKE_CASE__													= load_image(
						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'							).resize((512, 512)							)
						SCREAMING_SNAKE_CASE__													= load_image(
						    'https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'							).resize((512, 512)							)

						SCREAMING_SNAKE_CASE__													= pipe(
						    lowercase_       ,   lowercase_       ,   control_image=lowercase_       ,   generator=lowercase_       ,   output_type='np'       ,   num_inference_steps=50       ,   strength=0.6       ,   )

						SCREAMING_SNAKE_CASE__													= output.images[0]

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

						SCREAMING_SNAKE_CASE__													= load_numpy(
						    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/img2img.npy'							)

						assert np.abs(expected_image - image							).max() < 9e-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] )


