
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 						__lowercase:


       """simple docstring"""







       def __init__(     self					:			Optional[int]  ,      _lowerCAmelCase					:			str  ,      )					->   Any:
         _lowerCAmelCase						=		parent
         _lowerCAmelCase						=		13
         _lowerCAmelCase						=		7
         _lowerCAmelCase						=		True
         _lowerCAmelCase						=		True
         _lowerCAmelCase						=		True
         _lowerCAmelCase						=		True
         _lowerCAmelCase						=		True
         _lowerCAmelCase						=		False
         _lowerCAmelCase						=		False
         _lowerCAmelCase						=		False
         _lowerCAmelCase						=		2
         _lowerCAmelCase						=		99
         _lowerCAmelCase						=		0
         _lowerCAmelCase						=		32
         _lowerCAmelCase						=		2
         _lowerCAmelCase						=		4
         _lowerCAmelCase						=		0.1
         _lowerCAmelCase						=		0.1
         _lowerCAmelCase						=		512
         _lowerCAmelCase						=		16
         _lowerCAmelCase						=		2
         _lowerCAmelCase						=		0.02
         _lowerCAmelCase						=		3
         _lowerCAmelCase						=		4
         _lowerCAmelCase						=		'last'
         _lowerCAmelCase						=		True
         _lowerCAmelCase						=		None
         _lowerCAmelCase						=		0



       def SCREAMING_SNAKE_CASE_				(     self					:			Union[str, Any]       )					->   Optional[Any]:
         _lowerCAmelCase						=		ids_tensor([self.batch_size, self.seq_length]  ,      self.vocab_size       )
         _lowerCAmelCase						=		random_attention_mask([self.batch_size, self.seq_length]  ,      dtype=tf.floataa       )

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

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

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

         _lowerCAmelCase						=		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 SCREAMING_SNAKE_CASE_				(     self					:			Any  ,      _lowerCAmelCase					:			int  ,      _lowerCAmelCase					:			int  ,      _lowerCAmelCase					:			Tuple  ,      _lowerCAmelCase					:			Optional[int]  ,      _lowerCAmelCase					:			List[str]  ,      _lowerCAmelCase					:			int  ,      _lowerCAmelCase					:			Any  ,      _lowerCAmelCase					:			List[Any]  ,      _lowerCAmelCase					:			Union[str, Any]  ,      )					->   int:
         _lowerCAmelCase						=		TFXLMModel(config=UpperCAmelCase__       )
         _lowerCAmelCase						=		{'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
         _lowerCAmelCase						=		model(UpperCAmelCase__       )

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



       def SCREAMING_SNAKE_CASE_				(     self					:			Optional[int]  ,      _lowerCAmelCase					:			int  ,      _lowerCAmelCase					:			List[Any]  ,      _lowerCAmelCase					:			Any  ,      _lowerCAmelCase					:			Union[str, Any]  ,      _lowerCAmelCase					:			Union[str, Any]  ,      _lowerCAmelCase					:			int  ,      _lowerCAmelCase					:			Dict  ,      _lowerCAmelCase					:			Any  ,      _lowerCAmelCase					:			Optional[int]  ,      )					->   List[Any]:
         _lowerCAmelCase						=		TFXLMWithLMHeadModel(UpperCAmelCase__       )

         _lowerCAmelCase						=		{'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
         _lowerCAmelCase						=		model(UpperCAmelCase__       )

         _lowerCAmelCase						=		outputs

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



       def SCREAMING_SNAKE_CASE_				(     self					:			List[Any]  ,      _lowerCAmelCase					:			Dict  ,      _lowerCAmelCase					:			Tuple  ,      _lowerCAmelCase					:			Dict  ,      _lowerCAmelCase					:			Dict  ,      _lowerCAmelCase					:			List[str]  ,      _lowerCAmelCase					:			Dict  ,      _lowerCAmelCase					:			Optional[int]  ,      _lowerCAmelCase					:			List[Any]  ,      _lowerCAmelCase					:			int  ,      )					->   List[Any]:
         _lowerCAmelCase						=		TFXLMForQuestionAnsweringSimple(UpperCAmelCase__       )

         _lowerCAmelCase						=		{'input_ids': input_ids, 'lengths': input_lengths}

         _lowerCAmelCase						=		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 SCREAMING_SNAKE_CASE_				(     self					:			Dict  ,      _lowerCAmelCase					:			Union[str, Any]  ,      _lowerCAmelCase					:			List[str]  ,      _lowerCAmelCase					:			Union[str, Any]  ,      _lowerCAmelCase					:			str  ,      _lowerCAmelCase					:			Optional[int]  ,      _lowerCAmelCase					:			str  ,      _lowerCAmelCase					:			Any  ,      _lowerCAmelCase					:			Optional[Any]  ,      _lowerCAmelCase					:			int  ,      )					->   Any:
         _lowerCAmelCase						=		TFXLMForSequenceClassification(UpperCAmelCase__       )

         _lowerCAmelCase						=		{'input_ids': input_ids, 'lengths': input_lengths}

         _lowerCAmelCase						=		model(UpperCAmelCase__       )

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



       def SCREAMING_SNAKE_CASE_				(     self					:			Optional[int]  ,      _lowerCAmelCase					:			List[str]  ,      _lowerCAmelCase					:			str  ,      _lowerCAmelCase					:			Union[str, Any]  ,      _lowerCAmelCase					:			Tuple  ,      _lowerCAmelCase					:			Dict  ,      _lowerCAmelCase					:			Optional[Any]  ,      _lowerCAmelCase					:			str  ,      _lowerCAmelCase					:			Optional[Any]  ,      _lowerCAmelCase					:			Dict  ,      )					->   List[Any]:
         _lowerCAmelCase						=		self.num_labels
         _lowerCAmelCase						=		TFXLMForTokenClassification(config=UpperCAmelCase__       )
         _lowerCAmelCase						=		{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
         _lowerCAmelCase						=		model(UpperCAmelCase__       )
         self.parent.assertEqual(result.logits.shape  ,      (self.batch_size, self.seq_length, self.num_labels)       )



       def SCREAMING_SNAKE_CASE_				(     self					:			List[Any]  ,      _lowerCAmelCase					:			Dict  ,      _lowerCAmelCase					:			List[Any]  ,      _lowerCAmelCase					:			List[str]  ,      _lowerCAmelCase					:			Union[str, Any]  ,      _lowerCAmelCase					:			List[Any]  ,      _lowerCAmelCase					:			Tuple  ,      _lowerCAmelCase					:			Tuple  ,      _lowerCAmelCase					:			Optional[Any]  ,      _lowerCAmelCase					:			str  ,      )					->   int:
         _lowerCAmelCase						=		self.num_choices
         _lowerCAmelCase						=		TFXLMForMultipleChoice(config=UpperCAmelCase__       )
         _lowerCAmelCase						=		tf.tile(tf.expand_dims(UpperCAmelCase__  ,      1       )  ,      (1, self.num_choices, 1)       )
         _lowerCAmelCase						=		tf.tile(tf.expand_dims(UpperCAmelCase__  ,      1       )  ,      (1, self.num_choices, 1)       )
         _lowerCAmelCase						=		tf.tile(tf.expand_dims(UpperCAmelCase__  ,      1       )  ,      (1, self.num_choices, 1)       )
         _lowerCAmelCase						=		{
             'input_ids': multiple_choice_inputs_ids,
             'attention_mask': multiple_choice_input_mask,
             'token_type_ids': multiple_choice_token_type_ids,
         }
         _lowerCAmelCase						=		model(UpperCAmelCase__       )
         self.parent.assertEqual(result.logits.shape  ,      (self.batch_size, self.num_choices)       )






       def SCREAMING_SNAKE_CASE_				(     self					:			Optional[Any]       )					->   Optional[Any]:
         _lowerCAmelCase						=		self.prepare_config_and_inputs()
         (
             (
             _lowerCAmelCase   
         )	,       (
             _lowerCAmelCase   
         )	,       (
             _lowerCAmelCase   
         )	,       (
             _lowerCAmelCase   
         )	,       (
             _lowerCAmelCase   
         )	,       (
             _lowerCAmelCase   
         )	,       (
             _lowerCAmelCase   
         )	,       (
             _lowerCAmelCase   
         )	,       (
             _lowerCAmelCase   
         )	,          
         )						=		config_and_inputs
         _lowerCAmelCase						=		{
             'input_ids': input_ids,
             'token_type_ids': token_type_ids,
             'langs': token_type_ids,
             'lengths': input_lengths,
         }
         return config, inputs_dict





@require_tf
class 						__lowercase(     SCREAMING_SNAKE_CASE		,  SCREAMING_SNAKE_CASE		,  unittest.TestCase   ):


       """simple docstring"""







       UpperCamelCase_				 =							(
           (
               TFXLMModel,
               TFXLMWithLMHeadModel,
               TFXLMForSequenceClassification,
               TFXLMForQuestionAnsweringSimple,
               TFXLMForTokenClassification,
               TFXLMForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       UpperCamelCase_				 =							(
           (TFXLMWithLMHeadModel,) if is_tf_available() else ()
       )  # TODO (PVP): Check other models whether language generation is also applicable
       UpperCamelCase_				 =							(
           {
               "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 {}
       )
       UpperCamelCase_				 =							False
       UpperCamelCase_				 =							False



       def SCREAMING_SNAKE_CASE_				(     self					:			Any  ,      _lowerCAmelCase					:			Union[str, Any]  ,      _lowerCAmelCase					:			str  ,      _lowerCAmelCase					:			List[Any]  ,      _lowerCAmelCase					:			List[Any]  ,      _lowerCAmelCase					:			Union[str, Any]       )					->   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 SCREAMING_SNAKE_CASE_				(     self					:			Optional[Any]       )					->   str:
         _lowerCAmelCase						=		TFXLMModelTester(self       )
         _lowerCAmelCase						=		ConfigTester(self  ,      config_class=UpperCAmelCase__  ,      emb_dim=37       )



       def SCREAMING_SNAKE_CASE_				(     self					:			int       )					->   List[str]:
         self.config_tester.run_common_tests()



       def SCREAMING_SNAKE_CASE_				(     self					:			Dict       )					->   Optional[Any]:
         _lowerCAmelCase						=		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_model(*UpperCAmelCase__       )



       def SCREAMING_SNAKE_CASE_				(     self					:			str       )					->   Optional[Any]:
         _lowerCAmelCase						=		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_lm_head(*UpperCAmelCase__       )



       def SCREAMING_SNAKE_CASE_				(     self					:			Union[str, Any]       )					->   Optional[int]:
         _lowerCAmelCase						=		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_qa(*UpperCAmelCase__       )



       def SCREAMING_SNAKE_CASE_				(     self					:			int       )					->   Tuple:
         _lowerCAmelCase						=		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_sequence_classif(*UpperCAmelCase__       )



       def SCREAMING_SNAKE_CASE_				(     self					:			List[str]       )					->   Any:
         _lowerCAmelCase						=		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_for_token_classification(*UpperCAmelCase__       )



       def SCREAMING_SNAKE_CASE_				(     self					:			Tuple       )					->   Dict:
         _lowerCAmelCase						=		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCAmelCase__       )






       @slow
       def SCREAMING_SNAKE_CASE_				(     self					:			int       )					->   Union[str, Any]:
         for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _lowerCAmelCase						=		TFXLMModel.from_pretrained(UpperCAmelCase__       )
           self.assertIsNotNone(UpperCAmelCase__       )





@require_tf
class 						__lowercase(     unittest.TestCase   ):


       """simple docstring"""







       @slow
       def SCREAMING_SNAKE_CASE_				(     self					:			Optional[Any]       )					->   List[Any]:
         _lowerCAmelCase						=		TFXLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'       )
         _lowerCAmelCase						=		tf.convert_to_tensor([[14, 447]]  ,      dtype=tf.intaa       )  # the president
         _lowerCAmelCase						=		[
             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
         _lowerCAmelCase						=		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
