


import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


_lowercase							:   Optional[int]						=						False






@skip_mps
class    _UpperCamelCase     (       __snake_case     ,		__snake_case     ,		__snake_case     ,		unittest.TestCase					):

				"""simple docstring"""







				lowerCAmelCase					=			StableDiffusionAttendAndExcitePipeline
				lowerCAmelCase					=			False
				lowerCAmelCase					=			TEXT_TO_IMAGE_PARAMS
				lowerCAmelCase					=			TEXT_TO_IMAGE_BATCH_PARAMS.union({'token_indices'}					)
				lowerCAmelCase					=			TEXT_TO_IMAGE_IMAGE_PARAMS
				lowerCAmelCase					=			TEXT_TO_IMAGE_IMAGE_PARAMS

				@classmethod
				def   _UpperCAmelCase       (    cls )						->					List[Any]:
					super().setUpClass()
					torch.use_deterministic_algorithms(a__ )

				@classmethod
				def   _UpperCAmelCase       (    cls )						->					Tuple:
					super().tearDownClass()
					torch.use_deterministic_algorithms(a__ )

				def   _UpperCAmelCase       (    self )						->					Dict:
					torch.manual_seed(0 )
					A             =					UNetaDConditionModel(
					    block_out_channels=(32, 64)					, layers_per_block=1					, sample_size=32					, in_channels=4					, out_channels=4					, down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")					, up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")					, cross_attention_dim=32					, attention_head_dim=(2, 4)					, use_linear_projection=a__					, )
					A             =					DDIMScheduler(
					    beta_start=0.0_00_85					, beta_end=0.0_12					, beta_schedule="""scaled_linear"""					, clip_sample=a__					, set_alpha_to_one=a__					, )
					torch.manual_seed(0 )
					A             =					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					, sample_size=128					, )
					torch.manual_seed(0 )
					A             =					CLIPTextConfig(
					    bos_token_id=0					, eos_token_id=2					, hidden_size=32					, intermediate_size=37					, layer_norm_eps=1e-05					, num_attention_heads=4					, num_hidden_layers=5					, pad_token_id=1					, vocab_size=1000					, hidden_act="""gelu"""					, projection_dim=512					, )
					A             =					CLIPTextModel(a__ )
					A             =					CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

					A             =					{
					    """unet""": unet,
					    """scheduler""": scheduler,
					    """vae""": vae,
					    """text_encoder""": text_encoder,
					    """tokenizer""": tokenizer,
					    """safety_checker""": None,
					    """feature_extractor""": None,
					}

					return components

				def   _UpperCAmelCase       (    self					, a__					, a__=0 )						->					Optional[Any]:
					if str(a__ ).startswith("""mps""" ):
						A             =					torch.manual_seed(a__ )
					else:
						A             =					torch.Generator(device=a__ ).manual_seed(a__ )
					A             =					A             =					{
					    """prompt""": """a cat and a frog""",
					    """token_indices""": [2, 5],
					    """generator""": generator,
					    """num_inference_steps""": 1,
					    """guidance_scale""": 6.0,
					    """output_type""": """numpy""",
					    """max_iter_to_alter""": 2,
					    """thresholds""": {0: 0.7},
					}
					return inputs

				def   _UpperCAmelCase       (    self )						->					Union[str, Any]:
					A             =					"""cpu"""

					A             =					self.get_dummy_components()
					A             =					self.pipeline_class(**a__ )
					pipe.to(a__ )
					pipe.set_progress_bar_config(disable=a__ )

					A             =					self.get_dummy_inputs(a__ )
					A             =					pipe(**a__ ).images
					A             =					image[0, -3:, -3:, -1]

					self.assertEqual(image.shape					, (1, 64, 64, 3) )
					A             =					np.array(
					    [0.63_90_53_64, 0.62_89_73_07, 0.48_59_90_17, 0.5_13_36_24, 0.5_55_00_48, 0.45_76_95_16, 0.50_32_69_73, 0.5_02_31_39, 0.45_38_44_96] )
					A             =					np.abs(image_slice.flatten() - expected_slice ).max()
					self.assertLessEqual(a__					, 1e-3 )

				def   _UpperCAmelCase       (    self )						->					List[Any]:
					super().test_cpu_offload_forward_pass(expected_max_diff=5e-4 )

				def   _UpperCAmelCase       (    self )						->					Dict:
					# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
					self._test_inference_batch_consistent(batch_sizes=[1, 2] )

				def   _UpperCAmelCase       (    self )						->					Any:
					self._test_inference_batch_single_identical(batch_size=2					, expected_max_diff=7e-4 )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3 )

				def   _UpperCAmelCase       (    self )						->					str:
					super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4 )

				def   _UpperCAmelCase       (    self )						->					int:
					super().test_save_load_local(expected_max_difference=5e-4 )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					super().test_save_load_optional_components(expected_max_difference=4e-4 )






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

				"""simple docstring"""







				@classmethod
				def   _UpperCAmelCase       (    cls )						->					Tuple:
					super().setUpClass()
					torch.use_deterministic_algorithms(a__ )

				@classmethod
				def   _UpperCAmelCase       (    cls )						->					Dict:
					super().tearDownClass()
					torch.use_deterministic_algorithms(a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()

				def   _UpperCAmelCase       (    self )						->					int:
					A             =					torch.manual_seed(51 )

					A             =					StableDiffusionAttendAndExcitePipeline.from_pretrained(
					    """CompVis/stable-diffusion-v1-4"""					, safety_checker=a__					, torch_dtype=torch.floataa )
					pipe.to("""cuda""" )

					A             =					"""a painting of an elephant with glasses"""
					A             =					[5, 7]

					A             =					pipe(
					    prompt=a__					, token_indices=a__					, guidance_scale=7.5					, generator=a__					, num_inference_steps=5					, max_iter_to_alter=5					, output_type="""numpy"""					, ).images[0]

					A             =					load_numpy(
					    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy""" )
					assert np.abs((expected_image - image).max() ) < 5e-1







import unittest

from transformers import XLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
				import torch

				from transformers import (
				    XLMForMultipleChoice,
				    XLMForQuestionAnswering,
				    XLMForQuestionAnsweringSimple,
				    XLMForSequenceClassification,
				    XLMForTokenClassification,
				    XLMModel,
				    XLMWithLMHeadModel,
				)
				from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST






class    _UpperCamelCase     :

				"""simple docstring"""







				def __init__(    self					, a__					, a__=13					, a__=7					, a__=True					, a__=True					, a__=True					, a__=True					, a__=True					, a__=False					, a__=False					, a__=False					, a__=2					, a__=99					, a__=0					, a__=32					, a__=5					, a__=4					, a__=0.1					, a__=0.1					, a__=512					, a__=2					, a__=0.02					, a__=2					, a__=4					, a__="last"					, a__=True					, a__=None					, a__=0					, )						->					Any:
					A             =					parent
					A             =					batch_size
					A             =					seq_length
					A             =					is_training
					A             =					use_input_lengths
					A             =					use_token_type_ids
					A             =					use_labels
					A             =					gelu_activation
					A             =					sinusoidal_embeddings
					A             =					causal
					A             =					asm
					A             =					n_langs
					A             =					vocab_size
					A             =					n_special
					A             =					hidden_size
					A             =					num_hidden_layers
					A             =					num_attention_heads
					A             =					hidden_dropout_prob
					A             =					attention_probs_dropout_prob
					A             =					max_position_embeddings
					A             =					type_sequence_label_size
					A             =					initializer_range
					A             =					num_labels
					A             =					num_choices
					A             =					summary_type
					A             =					use_proj
					A             =					scope
					A             =					bos_token_id

				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					A             =					ids_tensor([self.batch_size, self.seq_length]					, self.vocab_size )
					A             =					random_attention_mask([self.batch_size, self.seq_length] )

					A             =					None
					if self.use_input_lengths:
						A             =					(
						    ids_tensor([self.batch_size]					, vocab_size=2 ) + self.seq_length - 2
						)  # small variation of seq_length

					A             =					None
					if self.use_token_type_ids:
						A             =					ids_tensor([self.batch_size, self.seq_length]					, self.n_langs )

					A             =					None
					A             =					None
					A             =					None
					if self.use_labels:
						A             =					ids_tensor([self.batch_size]					, self.type_sequence_label_size )
						A             =					ids_tensor([self.batch_size, self.seq_length]					, self.num_labels )
						A             =					ids_tensor([self.batch_size]					, 2 ).float()
						A             =					ids_tensor([self.batch_size]					, self.num_choices )

					A             =					self.get_config()

					return (
					    config,
					    input_ids,
					    token_type_ids,
					    input_lengths,
					    sequence_labels,
					    token_labels,
					    is_impossible_labels,
					    choice_labels,
					    input_mask,
					)

				def   _UpperCAmelCase       (    self )						->					int:
					return XLMConfig(
					    vocab_size=self.vocab_size					, n_special=self.n_special					, emb_dim=self.hidden_size					, n_layers=self.num_hidden_layers					, n_heads=self.num_attention_heads					, dropout=self.hidden_dropout_prob					, attention_dropout=self.attention_probs_dropout_prob					, gelu_activation=self.gelu_activation					, sinusoidal_embeddings=self.sinusoidal_embeddings					, asm=self.asm					, causal=self.causal					, n_langs=self.n_langs					, max_position_embeddings=self.max_position_embeddings					, initializer_range=self.initializer_range					, summary_type=self.summary_type					, use_proj=self.use_proj					, num_labels=self.num_labels					, bos_token_id=self.bos_token_id					, )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, )						->					str:
					A             =					XLMModel(config=a__ )
					model.to(a__ )
					model.eval()
					A             =					model(a__					, lengths=a__					, langs=a__ )
					A             =					model(a__					, langs=a__ )
					A             =					model(a__ )
					self.parent.assertEqual(result.last_hidden_state.shape					, (self.batch_size, self.seq_length, self.hidden_size) )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, )						->					str:
					A             =					XLMWithLMHeadModel(a__ )
					model.to(a__ )
					model.eval()

					A             =					model(a__					, token_type_ids=a__					, labels=a__ )
					self.parent.assertEqual(result.loss.shape					, () )
					self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.seq_length, self.vocab_size) )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, )						->					Any:
					A             =					XLMForQuestionAnsweringSimple(a__ )
					model.to(a__ )
					model.eval()

					A             =					model(a__ )

					A             =					model(a__					, start_positions=a__					, end_positions=a__ )
					A             =					outputs
					self.parent.assertEqual(result.start_logits.shape					, (self.batch_size, self.seq_length) )
					self.parent.assertEqual(result.end_logits.shape					, (self.batch_size, self.seq_length) )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, )						->					Optional[Any]:
					A             =					XLMForQuestionAnswering(a__ )
					model.to(a__ )
					model.eval()

					A             =					model(a__ )

					A             =					model(
					    a__					, start_positions=a__					, end_positions=a__					, cls_index=a__					, is_impossible=a__					, p_mask=a__					, )

					A             =					model(
					    a__					, start_positions=a__					, end_positions=a__					, cls_index=a__					, is_impossible=a__					, )

					((A)       ,      )             =					result_with_labels.to_tuple()

					A             =					model(a__					, start_positions=a__					, end_positions=a__ )

					((A)       ,      )             =					result_with_labels.to_tuple()

					self.parent.assertEqual(result_with_labels.loss.shape					, () )
					self.parent.assertEqual(result.start_top_log_probs.shape					, (self.batch_size, model.config.start_n_top) )
					self.parent.assertEqual(result.start_top_index.shape					, (self.batch_size, model.config.start_n_top) )
					self.parent.assertEqual(
					    result.end_top_log_probs.shape					, (self.batch_size, model.config.start_n_top * model.config.end_n_top) )
					self.parent.assertEqual(
					    result.end_top_index.shape					, (self.batch_size, model.config.start_n_top * model.config.end_n_top) )
					self.parent.assertEqual(result.cls_logits.shape					, (self.batch_size,) )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, )						->					Optional[Any]:
					A             =					XLMForSequenceClassification(a__ )
					model.to(a__ )
					model.eval()

					A             =					model(a__ )
					A             =					model(a__					, labels=a__ )
					self.parent.assertEqual(result.loss.shape					, () )
					self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.type_sequence_label_size) )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, )						->					List[str]:
					A             =					self.num_labels
					A             =					XLMForTokenClassification(a__ )
					model.to(a__ )
					model.eval()

					A             =					model(a__					, attention_mask=a__					, labels=a__ )
					self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.seq_length, self.num_labels) )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, a__					, )						->					Dict:
					A             =					self.num_choices
					A             =					XLMForMultipleChoice(config=a__ )
					model.to(a__ )
					model.eval()
					A             =					input_ids.unsqueeze(1 ).expand(-1					, self.num_choices					, -1 ).contiguous()
					A             =					token_type_ids.unsqueeze(1 ).expand(-1					, self.num_choices					, -1 ).contiguous()
					A             =					input_mask.unsqueeze(1 ).expand(-1					, self.num_choices					, -1 ).contiguous()
					A             =					model(
					    a__					, attention_mask=a__					, token_type_ids=a__					, labels=a__					, )
					self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.num_choices) )

				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					A             =					self.prepare_config_and_inputs()
					(
					    (
					    A
					)       ,      (
					    A
					)       ,      (
					    A
					)       ,      (
					    A
					)       ,      (
					    A
					)       ,      (
					    A
					)       ,      (
					    A
					)       ,      (
					    A
					)       ,      (
					    A
					)       ,      
					)             =					config_and_inputs
					A             =					{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """lengths""": input_lengths}
					return config, inputs_dict






@require_torch
class    _UpperCamelCase     (       __snake_case     ,		__snake_case     ,		__snake_case     ,		unittest.TestCase					):

				"""simple docstring"""







				lowerCAmelCase					=			(
				    (
				        XLMModel,
				        XLMWithLMHeadModel,
				        XLMForQuestionAnswering,
				        XLMForSequenceClassification,
				        XLMForQuestionAnsweringSimple,
				        XLMForTokenClassification,
				        XLMForMultipleChoice,
				    )
				    if is_torch_available()
				    else ()
				)
				lowerCAmelCase					=			(
				    (XLMWithLMHeadModel,) if is_torch_available() else ()
				)  # TODO (PVP): Check other models whether language generation is also applicable
				lowerCAmelCase					=			(
				    {
				        'feature-extraction': XLMModel,
				        'fill-mask': XLMWithLMHeadModel,
				        'question-answering': XLMForQuestionAnsweringSimple,
				        'text-classification': XLMForSequenceClassification,
				        'text-generation': XLMWithLMHeadModel,
				        'token-classification': XLMForTokenClassification,
				        'zero-shot': XLMForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__					, a__ )						->					Union[str, Any]:
					if (
					    pipeline_test_casse_name == "QAPipelineTests"
					    and tokenizer_name is not None
					    and not tokenizer_name.endswith("""Fast""" )
					):
						# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
						# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
						# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
						return True

					return False

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__=False )						->					Optional[Any]:
					A             =					super()._prepare_for_class(a__					, a__					, return_labels=a__ )

					if return_labels:
						if model_class.__name__ == "XLMForQuestionAnswering":
							A             =					torch.zeros(
							    self.model_tester.batch_size					, dtype=torch.long					, device=a__ )
							A             =					torch.zeros(
							    self.model_tester.batch_size					, dtype=torch.long					, device=a__ )

					return inputs_dict

				def   _UpperCAmelCase       (    self )						->					Union[str, Any]:
					A             =					XLMModelTester(self )
					A             =					ConfigTester(self					, config_class=a__					, emb_dim=37 )

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

				def   _UpperCAmelCase       (    self )						->					Any:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_model(*a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_lm_head(*a__ )

				def   _UpperCAmelCase       (    self )						->					Dict:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_simple_qa(*a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_qa(*a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_sequence_classif(*a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_token_classif(*a__ )

				def   _UpperCAmelCase       (    self )						->					Tuple:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_xlm_for_multiple_choice(*a__ )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__					, a__					, a__=False					, a__=1 )						->					List[str]:
					self.assertIsInstance(a__					, a__ )
					self.assertListEqual(
					    [isinstance(a__					, a__ ) for iter_attentions in attentions]					, [True] * len(a__ ) )
					self.assertEqual(len(a__ )					, (max_length - min_length) * num_beam_groups )

					for idx, iter_attentions in enumerate(a__ ):
						# adds PAD dummy token
						A             =					min_length + idx + 1
						A             =					min_length + idx + 1

						A             =					(
						    batch_size * num_beam_groups,
						    config.num_attention_heads,
						    tgt_len,
						    src_len,
						)
						# check attn size
						self.assertListEqual(
						    [layer_attention.shape for layer_attention in iter_attentions]					, [expected_shape] * len(a__ ) )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__					, a__					, a__=False					, a__=1 )						->					List[Any]:
					self.assertIsInstance(a__					, a__ )
					self.assertListEqual(
					    [isinstance(a__					, a__ ) for iter_hidden_states in hidden_states]					, [True] * len(a__ )					, )
					self.assertEqual(len(a__ )					, (max_length - min_length) * num_beam_groups )

					for idx, iter_hidden_states in enumerate(a__ ):
						# adds PAD dummy token
						A             =					min_length + idx + 1
						A             =					(batch_size * num_beam_groups, seq_len, config.hidden_size)
						# check hidden size
						self.assertListEqual(
						    [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]					, [expected_shape] * len(a__ )					, )
					pass

				@slow
				def   _UpperCAmelCase       (    self )						->					Any:
					for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						A             =					XLMModel.from_pretrained(a__ )
						self.assertIsNotNone(a__ )






@require_torch
class    _UpperCamelCase     (       unittest.TestCase					):

				"""simple docstring"""







				@slow
				def   _UpperCAmelCase       (    self )						->					List[Any]:
					A             =					XLMWithLMHeadModel.from_pretrained("""xlm-mlm-en-2048""" )
					model.to(a__ )
					A             =					torch.tensor([[14, 447]]					, dtype=torch.long					, device=a__ )  # the president
					A             =					[
					    14,
					    447,
					    14,
					    447,
					    14,
					    447,
					    14,
					    447,
					    14,
					    447,
					    14,
					    447,
					    14,
					    447,
					    14,
					    447,
					    14,
					    447,
					    14,
					    447,
					]  # the president the president the president the president the president the president the president the president the president the president
					# TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
					A             =					model.generate(a__					, do_sample=a__ )
					self.assertListEqual(output_ids[0].cpu().numpy().tolist()					, a__ )



