


"""simple docstring"""






from __future__ import annotations

import unittest

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

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


if is_tf_available():
	import tensorflow as tf

	from transformers import (
	    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
	    TFXLMForMultipleChoice,
	    TFXLMForQuestionAnsweringSimple,
	    TFXLMForSequenceClassification,
	    TFXLMForTokenClassification,
	    TFXLMModel,
	    TFXLMWithLMHeadModel,
	    XLMConfig,
	)


class       lowerCamelCase_		:





				"""simple docstring"""







				def __init__(    self							,		UpperCAmelCase__							,		):
								SCREAMING_SNAKE_CASE__  				=					parent
								SCREAMING_SNAKE_CASE__  				=					13
								SCREAMING_SNAKE_CASE__  				=					7
								SCREAMING_SNAKE_CASE__  				=					True
								SCREAMING_SNAKE_CASE__  				=					True
								SCREAMING_SNAKE_CASE__  				=					True
								SCREAMING_SNAKE_CASE__  				=					True
								SCREAMING_SNAKE_CASE__  				=					True
								SCREAMING_SNAKE_CASE__  				=					False
								SCREAMING_SNAKE_CASE__  				=					False
								SCREAMING_SNAKE_CASE__  				=					False
								SCREAMING_SNAKE_CASE__  				=					2
								SCREAMING_SNAKE_CASE__  				=					99
								SCREAMING_SNAKE_CASE__  				=					0
								SCREAMING_SNAKE_CASE__  				=					32
								SCREAMING_SNAKE_CASE__  				=					2
								SCREAMING_SNAKE_CASE__  				=					4
								SCREAMING_SNAKE_CASE__  				=					0.1
								SCREAMING_SNAKE_CASE__  				=					0.1
								SCREAMING_SNAKE_CASE__  				=					512
								SCREAMING_SNAKE_CASE__  				=					16
								SCREAMING_SNAKE_CASE__  				=					2
								SCREAMING_SNAKE_CASE__  				=					0.02
								SCREAMING_SNAKE_CASE__  				=					3
								SCREAMING_SNAKE_CASE__  				=					4
								SCREAMING_SNAKE_CASE__  				=					"last"
								SCREAMING_SNAKE_CASE__  				=					True
								SCREAMING_SNAKE_CASE__  				=					None
								SCREAMING_SNAKE_CASE__  				=					0



				def 	lowerCAmelCase__		(    self  ):
								SCREAMING_SNAKE_CASE__  				=					ids_tensor([self.batch_size, self.seq_length]							,		self.vocab_size  )
								SCREAMING_SNAKE_CASE__  				=					random_attention_mask([self.batch_size, self.seq_length]							,		dtype=tf.floataa  )

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

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

								SCREAMING_SNAKE_CASE__  				=					None
								SCREAMING_SNAKE_CASE__  				=					None
								SCREAMING_SNAKE_CASE__  				=					None
								if self.use_labels:
												SCREAMING_SNAKE_CASE__  				=					ids_tensor([self.batch_size]							,		self.type_sequence_label_size  )
												SCREAMING_SNAKE_CASE__  				=					ids_tensor([self.batch_size, self.seq_length]							,		self.num_labels  )
												SCREAMING_SNAKE_CASE__  				=					ids_tensor([self.batch_size]							,		2							,		dtype=tf.floataa  )
												SCREAMING_SNAKE_CASE__  				=					ids_tensor([self.batch_size]							,		self.num_choices  )

								SCREAMING_SNAKE_CASE__  				=					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							,		bos_token_id=self.bos_token_id							,		)

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



				def 	lowerCAmelCase__		(    self							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		):
								SCREAMING_SNAKE_CASE__  				=					TFXLMModel(config=UpperCAmelCase__  )
								SCREAMING_SNAKE_CASE__  				=					{"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
								SCREAMING_SNAKE_CASE__  				=					model(UpperCAmelCase__  )

								SCREAMING_SNAKE_CASE__  				=					[input_ids, input_mask]
								SCREAMING_SNAKE_CASE__  				=					model(UpperCAmelCase__  )
								self.parent.assertEqual(result.last_hidden_state.shape							,		(self.batch_size, self.seq_length, self.hidden_size)  )



				def 	lowerCAmelCase__		(    self							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		):
								SCREAMING_SNAKE_CASE__  				=					TFXLMWithLMHeadModel(UpperCAmelCase__  )

								SCREAMING_SNAKE_CASE__  				=					{"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
								SCREAMING_SNAKE_CASE__  				=					model(UpperCAmelCase__  )

								SCREAMING_SNAKE_CASE__  				=					outputs

								self.parent.assertEqual(result.logits.shape							,		(self.batch_size, self.seq_length, self.vocab_size)  )



				def 	lowerCAmelCase__		(    self							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		):
								SCREAMING_SNAKE_CASE__  				=					TFXLMForQuestionAnsweringSimple(UpperCAmelCase__  )

								SCREAMING_SNAKE_CASE__  				=					{"input_ids": input_ids, "lengths": input_lengths}

								SCREAMING_SNAKE_CASE__  				=					model(UpperCAmelCase__  )

								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 	lowerCAmelCase__		(    self							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		):
								SCREAMING_SNAKE_CASE__  				=					TFXLMForSequenceClassification(UpperCAmelCase__  )

								SCREAMING_SNAKE_CASE__  				=					{"input_ids": input_ids, "lengths": input_lengths}

								SCREAMING_SNAKE_CASE__  				=					model(UpperCAmelCase__  )

								self.parent.assertEqual(result.logits.shape							,		(self.batch_size, self.type_sequence_label_size)  )



				def 	lowerCAmelCase__		(    self							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		):
								SCREAMING_SNAKE_CASE__  				=					self.num_labels
								SCREAMING_SNAKE_CASE__  				=					TFXLMForTokenClassification(config=UpperCAmelCase__  )
								SCREAMING_SNAKE_CASE__  				=					{"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
								SCREAMING_SNAKE_CASE__  				=					model(UpperCAmelCase__  )
								self.parent.assertEqual(result.logits.shape							,		(self.batch_size, self.seq_length, self.num_labels)  )



				def 	lowerCAmelCase__		(    self							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		):
								SCREAMING_SNAKE_CASE__  				=					self.num_choices
								SCREAMING_SNAKE_CASE__  				=					TFXLMForMultipleChoice(config=UpperCAmelCase__  )
								SCREAMING_SNAKE_CASE__  				=					tf.tile(tf.expand_dims(UpperCAmelCase__							,		1  )							,		(1, self.num_choices, 1)  )
								SCREAMING_SNAKE_CASE__  				=					tf.tile(tf.expand_dims(UpperCAmelCase__							,		1  )							,		(1, self.num_choices, 1)  )
								SCREAMING_SNAKE_CASE__  				=					tf.tile(tf.expand_dims(UpperCAmelCase__							,		1  )							,		(1, self.num_choices, 1)  )
								SCREAMING_SNAKE_CASE__  				=					{
								    "input_ids": multiple_choice_inputs_ids,
								    "attention_mask": multiple_choice_input_mask,
								    "token_type_ids": multiple_choice_token_type_ids,
								}
								SCREAMING_SNAKE_CASE__  				=					model(UpperCAmelCase__  )
								self.parent.assertEqual(result.logits.shape							,		(self.batch_size, self.num_choices)  )






				def 	lowerCAmelCase__		(    self  ):
								SCREAMING_SNAKE_CASE__  				=					self.prepare_config_and_inputs()
								(
								    (
								    SCREAMING_SNAKE_CASE__
								)				,   (
								    SCREAMING_SNAKE_CASE__
								)				,   (
								    SCREAMING_SNAKE_CASE__
								)				,   (
								    SCREAMING_SNAKE_CASE__
								)				,   (
								    SCREAMING_SNAKE_CASE__
								)				,   (
								    SCREAMING_SNAKE_CASE__
								)				,   (
								    SCREAMING_SNAKE_CASE__
								)				,   (
								    SCREAMING_SNAKE_CASE__
								)				,   (
								    SCREAMING_SNAKE_CASE__
								)				,   
								)  				=					config_and_inputs
								SCREAMING_SNAKE_CASE__  				=					{
								    "input_ids": input_ids,
								    "token_type_ids": token_type_ids,
								    "langs": token_type_ids,
								    "lengths": input_lengths,
								}
								return config, inputs_dict


@require_tf
class       lowerCamelCase_		(      lowercase							,	lowercase							,	unittest.TestCase ):





				"""simple docstring"""







				_lowerCAmelCase   :   List[Any]   				=       (
				    (
				        TFXLMModel,
				        TFXLMWithLMHeadModel,
				        TFXLMForSequenceClassification,
				        TFXLMForQuestionAnsweringSimple,
				        TFXLMForTokenClassification,
				        TFXLMForMultipleChoice,
				    )
				    if is_tf_available()
				    else ()
				)
				_lowerCAmelCase   :   Dict   				=       (
				    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
				)  # TODO (PVP): Check other models whether language generation is also applicable
				_lowerCAmelCase   :   List[str]   				=       (
				    {
				        "feature-extraction": TFXLMModel,
				        "fill-mask": TFXLMWithLMHeadModel,
				        "question-answering": TFXLMForQuestionAnsweringSimple,
				        "text-classification": TFXLMForSequenceClassification,
				        "text-generation": TFXLMWithLMHeadModel,
				        "token-classification": TFXLMForTokenClassification,
				        "zero-shot": TFXLMForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				_lowerCAmelCase   :   List[Any]   				=       False
				_lowerCAmelCase   :   List[Any]   				=       False



				def 	lowerCAmelCase__		(    self							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__							,		UpperCAmelCase__  ):
								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 	lowerCAmelCase__		(    self  ):
								SCREAMING_SNAKE_CASE__  				=					TFXLMModelTester(self  )
								SCREAMING_SNAKE_CASE__  				=					ConfigTester(self							,		config_class=UpperCAmelCase__							,		emb_dim=37  )



				def 	lowerCAmelCase__		(    self  ):
								self.config_tester.run_common_tests()



				def 	lowerCAmelCase__		(    self  ):
								SCREAMING_SNAKE_CASE__  				=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_model(*UpperCAmelCase__  )



				def 	lowerCAmelCase__		(    self  ):
								SCREAMING_SNAKE_CASE__  				=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_lm_head(*UpperCAmelCase__  )



				def 	lowerCAmelCase__		(    self  ):
								SCREAMING_SNAKE_CASE__  				=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_qa(*UpperCAmelCase__  )



				def 	lowerCAmelCase__		(    self  ):
								SCREAMING_SNAKE_CASE__  				=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_sequence_classif(*UpperCAmelCase__  )



				def 	lowerCAmelCase__		(    self  ):
								SCREAMING_SNAKE_CASE__  				=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_for_token_classification(*UpperCAmelCase__  )



				def 	lowerCAmelCase__		(    self  ):
								SCREAMING_SNAKE_CASE__  				=					self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCAmelCase__  )






				@slow
				def 	lowerCAmelCase__		(    self  ):
								for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												SCREAMING_SNAKE_CASE__  				=					TFXLMModel.from_pretrained(UpperCAmelCase__  )
												self.assertIsNotNone(UpperCAmelCase__  )


@require_tf
class       lowerCamelCase_		(      unittest.TestCase ):





				"""simple docstring"""







				@slow
				def 	lowerCAmelCase__		(    self  ):
								SCREAMING_SNAKE_CASE__  				=					TFXLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"  )
								SCREAMING_SNAKE_CASE__  				=					tf.convert_to_tensor([[14, 447]]							,		dtype=tf.intaa  )  # the president
								SCREAMING_SNAKE_CASE__  				=					[
								    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
								SCREAMING_SNAKE_CASE__  				=					model.generate(UpperCAmelCase__							,		do_sample=UpperCAmelCase__  )
								self.assertListEqual(output_ids[0].numpy().tolist()							,		UpperCAmelCase__  )




"""simple docstring"""






import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionDualGuidedPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


_lowerCamelCase  =	False


@nightly
@require_torch_gpu
class       lowerCamelCase_		(      unittest.TestCase ):





				"""simple docstring"""







				def 	lowerCAmelCase__		(    self  ):
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()



				def 	lowerCAmelCase__		(    self  ):
								SCREAMING_SNAKE_CASE__  				=					VersatileDiffusionDualGuidedPipeline.from_pretrained("shi-labs/versatile-diffusion"  )
								# remove text_unet
								pipe.remove_unused_weights()
								pipe.to(UpperCAmelCase__  )
								pipe.set_progress_bar_config(disable=UpperCAmelCase__  )

								SCREAMING_SNAKE_CASE__  				=					load_image(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg"  )

								SCREAMING_SNAKE_CASE__  				=					torch.manual_seed(0  )
								SCREAMING_SNAKE_CASE__  				=					pipe(
								    prompt="first prompt"							,		image=UpperCAmelCase__							,		text_to_image_strength=0.75							,		generator=UpperCAmelCase__							,		guidance_scale=7.5							,		num_inference_steps=2							,		output_type="numpy"							,		).images

								with tempfile.TemporaryDirectory() as tmpdirname:
												pipe.save_pretrained(UpperCAmelCase__  )
												SCREAMING_SNAKE_CASE__  				=					VersatileDiffusionDualGuidedPipeline.from_pretrained(UpperCAmelCase__  )

								pipe.to(UpperCAmelCase__  )
								pipe.set_progress_bar_config(disable=UpperCAmelCase__  )

								SCREAMING_SNAKE_CASE__  				=					generator.manual_seed(0  )
								SCREAMING_SNAKE_CASE__  				=					pipe(
								    prompt="first prompt"							,		image=UpperCAmelCase__							,		text_to_image_strength=0.75							,		generator=UpperCAmelCase__							,		guidance_scale=7.5							,		num_inference_steps=2							,		output_type="numpy"							,		).images

								assert np.abs(image - new_image  ).sum() < 1e-5, "Models don't have the same forward pass"






				def 	lowerCAmelCase__		(    self  ):
								SCREAMING_SNAKE_CASE__  				=					VersatileDiffusionDualGuidedPipeline.from_pretrained("shi-labs/versatile-diffusion"  )
								pipe.remove_unused_weights()
								pipe.to(UpperCAmelCase__  )
								pipe.set_progress_bar_config(disable=UpperCAmelCase__  )

								SCREAMING_SNAKE_CASE__  				=					"cyberpunk 2077"
								SCREAMING_SNAKE_CASE__  				=					load_image(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg"  )
								SCREAMING_SNAKE_CASE__  				=					torch.manual_seed(0  )
								SCREAMING_SNAKE_CASE__  				=					pipe(
								    prompt=UpperCAmelCase__							,		image=UpperCAmelCase__							,		text_to_image_strength=0.75							,		generator=UpperCAmelCase__							,		guidance_scale=7.5							,		num_inference_steps=50							,		output_type="numpy"							,		).images

								SCREAMING_SNAKE_CASE__  				=					image[0, 253:256, 253:256, -1]

								assert image.shape == (1, 512, 512, 3)
								SCREAMING_SNAKE_CASE__  				=					np.array([0.0_787, 0.0_849, 0.0_826, 0.0_812, 0.0_807, 0.0_795, 0.0_818, 0.0_798, 0.0_779]  )

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