





from __future__ import annotations

import unittest
import warnings

from transformers import AutoTokenizer, MarianConfig, MarianTokenizer, TranslationPipeline, is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow
from transformers.utils import cached_property

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


if is_tf_available():
							import tensorflow as tf

							from transformers import TFAutoModelForSeqaSeqLM, TFMarianModel, TFMarianMTModel

@require_tf
class 					__A   :
				__A            = MarianConfig
				__A            = {}
				__A            = """gelu"""


				def __init__(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_=13      ,       UpperCAmelCase_=7      ,       UpperCAmelCase_=True      ,       UpperCAmelCase_=False      ,       UpperCAmelCase_=99      ,       UpperCAmelCase_=32      ,       UpperCAmelCase_=2      ,       UpperCAmelCase_=4      ,       UpperCAmelCase_=37      ,       UpperCAmelCase_=0.1      ,       UpperCAmelCase_=0.1      ,       UpperCAmelCase_=20      ,       UpperCAmelCase_=2      ,       UpperCAmelCase_=1      ,       UpperCAmelCase_=0      ,       ):
								lowerCamelCase		       =parent
								lowerCamelCase		       =batch_size
								lowerCamelCase		       =seq_length
								lowerCamelCase		       =is_training
								lowerCamelCase		       =use_labels
								lowerCamelCase		       =vocab_size
								lowerCamelCase		       =hidden_size
								lowerCamelCase		       =num_hidden_layers
								lowerCamelCase		       =num_attention_heads
								lowerCamelCase		       =intermediate_size

								lowerCamelCase		       =hidden_dropout_prob
								lowerCamelCase		       =attention_probs_dropout_prob
								lowerCamelCase		       =max_position_embeddings
								lowerCamelCase		       =eos_token_id
								lowerCamelCase		       =pad_token_id
								lowerCamelCase		       =bos_token_id


				def _snake_case				(						self							):
								lowerCamelCase		       =ids_tensor([self.batch_size, self.seq_length - 1]      ,       self.vocab_size							)
								lowerCamelCase		       =tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size							)      ,       1							)
								lowerCamelCase		       =tf.concat([input_ids, eos_tensor]      ,       axis=1							)

								lowerCamelCase		       =ids_tensor([self.batch_size, self.seq_length]      ,       self.vocab_size							)

								lowerCamelCase		       =self.config_cls(
								    vocab_size=self.vocab_size      ,       d_model=self.hidden_size      ,       encoder_layers=self.num_hidden_layers      ,       decoder_layers=self.num_hidden_layers      ,       encoder_attention_heads=self.num_attention_heads      ,       decoder_attention_heads=self.num_attention_heads      ,       encoder_ffn_dim=self.intermediate_size      ,       decoder_ffn_dim=self.intermediate_size      ,       dropout=self.hidden_dropout_prob      ,       attention_dropout=self.attention_probs_dropout_prob      ,       max_position_embeddings=self.max_position_embeddings      ,       eos_token_ids=[2]      ,       bos_token_id=self.bos_token_id      ,       pad_token_id=self.pad_token_id      ,       decoder_start_token_id=self.pad_token_id      ,       **self.config_updates      ,       )
								lowerCamelCase		       =prepare_marian_inputs_dict(UpperCAmelCase_      ,       UpperCAmelCase_      ,       UpperCAmelCase_							)
								return config, inputs_dict


				def _snake_case				(						self      ,       UpperCAmelCase_      ,       UpperCAmelCase_							):
								lowerCamelCase		       =TFMarianModel(config=UpperCAmelCase_							).get_decoder()
								lowerCamelCase		       =inputs_dict["""input_ids"""]

								lowerCamelCase		       =input_ids[:1, :]
								lowerCamelCase		       =inputs_dict["""attention_mask"""][:1, :]
								lowerCamelCase		       =inputs_dict["""head_mask"""]
								lowerCamelCase		       =1

								# first forward pass
								lowerCamelCase		       =model(UpperCAmelCase_      ,       attention_mask=UpperCAmelCase_      ,       head_mask=UpperCAmelCase_      ,       use_cache=UpperCAmelCase_							)

								lowerCamelCase       ,     lowerCamelCase		       =outputs.to_tuple()

								# create hypothetical next token and extent to next_input_ids
								lowerCamelCase		       =ids_tensor((self.batch_size, 3)      ,       config.vocab_size							)
								lowerCamelCase		       =tf.cast(ids_tensor((self.batch_size, 3)      ,       2							)      ,       tf.inta							)

								# append to next input_ids and
								lowerCamelCase		       =tf.concat([input_ids, next_tokens]      ,       axis=-1							)
								lowerCamelCase		       =tf.concat([attention_mask, next_attn_mask]      ,       axis=-1							)

								lowerCamelCase		       =model(UpperCAmelCase_      ,       attention_mask=UpperCAmelCase_							)[0]
								lowerCamelCase		       =model(UpperCAmelCase_      ,       attention_mask=UpperCAmelCase_      ,       past_key_values=UpperCAmelCase_							)[0]

								self.parent.assertEqual(next_tokens.shape[1]      ,       output_from_past.shape[1]							)

								# select random slice
								lowerCamelCase		       =int(ids_tensor((1,)      ,       output_from_past.shape[-1]							)							)
								lowerCamelCase		       =output_from_no_past[:, -3:, random_slice_idx]
								lowerCamelCase		       =output_from_past[:, :, random_slice_idx]

								# test that outputs are equal for slice
								tf.debugging.assert_near(UpperCAmelCase_      ,       UpperCAmelCase_      ,       rtol=1E-3							)





def    _lowercase    (  _UpperCAmelCase	,					_UpperCAmelCase	,					_UpperCAmelCase	,					_UpperCAmelCase=None	,					_UpperCAmelCase=None	,					_UpperCAmelCase=None	,					_UpperCAmelCase=None	,					_UpperCAmelCase=None	,					)  ->     Any:
				if attention_mask is None:
								lowerCamelCase		       =tf.cast(tf.math.not_equal(_UpperCAmelCase	,					config.pad_token_id )	,					tf.inta )
				if decoder_attention_mask is None:
								lowerCamelCase		       =tf.concat(
								    [
								        tf.ones(decoder_input_ids[:, :1].shape	,					dtype=tf.inta ),
								        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]	,					config.pad_token_id )	,					tf.inta ),
								    ]	,					axis=-1	,					)
				if head_mask is None:
								lowerCamelCase		       =tf.ones((config.encoder_layers, config.encoder_attention_heads) )
				if decoder_head_mask is None:
								lowerCamelCase		       =tf.ones((config.decoder_layers, config.decoder_attention_heads) )
				if cross_attn_head_mask is None:
								lowerCamelCase		       =tf.ones((config.decoder_layers, config.decoder_attention_heads) )
				return {
				    "input_ids": input_ids,
				    "decoder_input_ids": decoder_input_ids,
				    "attention_mask": attention_mask,
				    "decoder_attention_mask": decoder_attention_mask,
				    "head_mask": head_mask,
				    "decoder_head_mask": decoder_head_mask,
				    "cross_attn_head_mask": cross_attn_head_mask,
				}

@require_tf
class 					__A   (  a			,    a			,    unittest.TestCase			):
				__A            = (TFMarianMTModel, TFMarianModel) if is_tf_available() else ()
				__A            = (TFMarianMTModel,) if is_tf_available() else ()
				__A            = (
				    {
				        """conversational""": TFMarianMTModel,
				        """feature-extraction""": TFMarianModel,
				        """summarization""": TFMarianMTModel,
				        """text2text-generation""": TFMarianMTModel,
				        """translation""": TFMarianMTModel,
				    }
				    if is_tf_available()
				    else {}
				)
				__A            = True
				__A            = False
				__A            = False


				def _snake_case				(						self							):
								lowerCamelCase		       =TFMarianModelTester(self							)
								lowerCamelCase		       =ConfigTester(self      ,       config_class=UpperCAmelCase_							)


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


				def _snake_case				(						self							):
								lowerCamelCase		       =self.model_tester.prepare_config_and_inputs_for_common()
								self.model_tester.check_decoder_model_past_large_inputs(*UpperCAmelCase_							)




@require_tf
class 					__A   (  unittest.TestCase			):
				__A            = 10_00  # show more chars for failing integration tests


				@classmethod
				def _snake_case				(						cls							):
								lowerCamelCase		       =f"""Helsinki-NLP/opus-mt-{cls.src}-{cls.tgt}"""
								return cls


				@cached_property
				def _snake_case				(						self							):
								return AutoTokenizer.from_pretrained(self.model_name							)


				@property
				def _snake_case				(						self							):
								return self.tokenizer.eos_token_id


				@cached_property
				def _snake_case				(						self							):
								warnings.simplefilter("""error"""							)
								lowerCamelCase		       =TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name							)
								assert isinstance(UpperCAmelCase_      ,       UpperCAmelCase_							)
								lowerCamelCase		       =model.config
								self.assertListEqual(c.bad_words_ids      ,       [[c.pad_token_id]]							)
								self.assertEqual(c.max_length      ,       512							)
								self.assertEqual(c.decoder_start_token_id      ,       c.pad_token_id							)
								return model


				def _snake_case				(						self      ,       **UpperCAmelCase_							):
								lowerCamelCase		       =self.translate_src_text(**UpperCAmelCase_							)
								self.assertListEqual(self.expected_text      ,       UpperCAmelCase_							)


				def _snake_case				(						self      ,       **UpperCAmelCase_							):
								lowerCamelCase		       =self.tokenizer(self.src_text      ,       **UpperCAmelCase_      ,       padding=UpperCAmelCase_      ,       return_tensors="""tf"""							)
								lowerCamelCase		       =self.model.generate(
								    model_inputs.input_ids      ,       attention_mask=model_inputs.attention_mask      ,       num_beams=2      ,       max_length=128							)
								lowerCamelCase		       =self.tokenizer.batch_decode(generated_ids.numpy()      ,       skip_special_tokens=UpperCAmelCase_							)
								return generated_words




@require_sentencepiece
@require_tokenizers
@require_tf
class 					__A   (  a			):
				__A            = """mt"""
				__A            = """en"""
				__A            = ["""Billi messu b'mod ġentili, Ġesù fejjaq raġel li kien milqut bil - marda kerha tal - ġdiem."""]
				__A            = ["""Touching gently, Jesus healed a man who was affected by the sad disease of leprosy."""]


				@unittest.skip("""Skipping until #12647 is resolved."""							)
				@slow
				def _snake_case				(						self							):
								self._assert_generated_batch_equal_expected()




@require_sentencepiece
@require_tokenizers
@require_tf
class 					__A   (  a			):
				__A            = """en"""
				__A            = """zh"""
				__A            = ["""My name is Wolfgang and I live in Berlin"""]
				__A            = ["""我叫沃尔夫冈 我住在柏林"""]


				@unittest.skip("""Skipping until #12647 is resolved."""							)
				@slow
				def _snake_case				(						self							):
								self._assert_generated_batch_equal_expected()




@require_sentencepiece
@require_tokenizers
@require_tf
class 					__A   (  a			):
				__A            = """en"""
				__A            = """ROMANCE"""
				__A            = [
				    """>>fr<< Don't spend so much time watching TV.""",
				    """>>pt<< Your message has been sent.""",
				    """>>es<< He's two years older than me.""",
				]
				__A            = [
				    """Ne passez pas autant de temps à regarder la télé.""",
				    """A sua mensagem foi enviada.""",
				    """Es dos años más viejo que yo.""",
				]


				@unittest.skip("""Skipping until #12647 is resolved."""							)
				@slow
				def _snake_case				(						self							):
								self._assert_generated_batch_equal_expected()


				@unittest.skip("""Skipping until #12647 is resolved."""							)
				@slow
				def _snake_case				(						self							):
								lowerCamelCase		       =TranslationPipeline(self.model      ,       self.tokenizer      ,       framework="""tf"""							)
								lowerCamelCase		       =pipeline(self.src_text							)
								self.assertEqual(self.expected_text      ,       [x["""translation_text"""] for x in output]							)










"""simple docstring"""







import numpy as np
import torch
import torch.nn as nn
from transformers import CLIPConfig, CLIPVisionModel, PreTrainedModel

from ...utils import logging


UpperCAmelCase:   Dict       			=							logging.get_logger(__name__)


def       __SCREAMING_SNAKE_CASE      (   __UpperCAmelCase					,							__UpperCAmelCase	):
		_lowercase							:      List[str]			=					nn.functional.normalize(__UpperCAmelCase	)
		_lowercase							:      int			=					nn.functional.normalize(__UpperCAmelCase	)
		return torch.mm(__UpperCAmelCase					,							normalized_text_embeds.t()	)





class    UpperCamelCase     (			snake_case    ):




	"""simple docstring"""
	SCREAMING_SNAKE_CASE_				:    List[str]		    =   CLIPConfig

	SCREAMING_SNAKE_CASE_				:    List[Any]		    =   ["CLIPEncoderLayer"]






	def __init__(			self							,UpperCAmelCase_					):
			super().__init__(UpperCAmelCase_					)

			_lowercase							:      Any			=					CLIPVisionModel(config.vision_config					)
			_lowercase							:      Any			=					nn.Linear(config.vision_config.hidden_size							,config.projection_dim							,bias=UpperCAmelCase_					)

			_lowercase							:      Dict			=					nn.Parameter(torch.ones(17							,config.projection_dim					)							,requires_grad=UpperCAmelCase_					)
			_lowercase							:      Tuple			=					nn.Parameter(torch.ones(3							,config.projection_dim					)							,requires_grad=UpperCAmelCase_					)

			_lowercase							:      Optional[int]			=					nn.Parameter(torch.ones(17					)							,requires_grad=UpperCAmelCase_					)
			_lowercase							:      List[Any]			=					nn.Parameter(torch.ones(3					)							,requires_grad=UpperCAmelCase_					)






	@torch.no_grad()
	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_					):
			_lowercase							:      List[str]			=					self.vision_model(UpperCAmelCase_					)[1]  # pooled_output
			_lowercase							:      str			=					self.visual_projection(UpperCAmelCase_					)

			# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
			_lowercase							:      Union[str, Any]			=					cosine_distance(UpperCAmelCase_							,self.special_care_embeds					).cpu().float().numpy()
			_lowercase							:      str			=					cosine_distance(UpperCAmelCase_							,self.concept_embeds					).cpu().float().numpy()

			_lowercase							:      List[str]			=					[]
			_lowercase							:      Optional[Any]			=					image_embeds.shape[0]
			for i in range(UpperCAmelCase_					):
					_lowercase							:      int			=					{"""special_scores""": {}, """special_care""": [], """concept_scores""": {}, """bad_concepts""": []}

					# increase this value to create a stronger `nfsw` filter
					# at the cost of increasing the possibility of filtering benign images
					_lowercase							:      str			=					0.0

					for concept_idx in range(len(special_cos_dist[0]					)					):
							_lowercase							:      Optional[Any]			=					special_cos_dist[i][concept_idx]
							_lowercase							:      str			=					self.special_care_embeds_weights[concept_idx].item()
							_lowercase							:      Tuple			=					round(concept_cos - concept_threshold + adjustment							,3					)
							if result_img["special_scores"][concept_idx] > 0:
									result_img["special_care"].append({concept_idx, result_img["""special_scores"""][concept_idx]}					)
									_lowercase							:      Union[str, Any]			=					0.01

					for concept_idx in range(len(cos_dist[0]					)					):
							_lowercase							:      Union[str, Any]			=					cos_dist[i][concept_idx]
							_lowercase							:      str			=					self.concept_embeds_weights[concept_idx].item()
							_lowercase							:      str			=					round(concept_cos - concept_threshold + adjustment							,3					)
							if result_img["concept_scores"][concept_idx] > 0:
									result_img["bad_concepts"].append(UpperCAmelCase_					)

					result.append(UpperCAmelCase_					)

			_lowercase							:      List[str]			=					[len(res["""bad_concepts"""]					) > 0 for res in result]

			for idx, has_nsfw_concept in enumerate(UpperCAmelCase_					):
					if has_nsfw_concept:
							if torch.is_tensor(UpperCAmelCase_					) or torch.is_tensor(images[0]					):
									_lowercase							:      List[Any]			=					torch.zeros_like(images[idx]					)  # black image
							else:
									_lowercase							:      Any			=					np.zeros(images[idx].shape					)  # black image

			if any(UpperCAmelCase_					):
					logger.warning(
					    """Potential NSFW content was detected in one or more images. A black image will be returned instead."""
					    """ Try again with a different prompt and/or seed."""					)

			return images, has_nsfw_concepts






	@torch.no_grad()
	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_					):
			_lowercase							:      List[Any]			=					self.vision_model(UpperCAmelCase_					)[1]  # pooled_output
			_lowercase							:      Optional[int]			=					self.visual_projection(UpperCAmelCase_					)

			_lowercase							:      Union[str, Any]			=					cosine_distance(UpperCAmelCase_							,self.special_care_embeds					)
			_lowercase							:      Tuple			=					cosine_distance(UpperCAmelCase_							,self.concept_embeds					)

			# increase this value to create a stronger `nsfw` filter
			# at the cost of increasing the possibility of filtering benign images
			_lowercase							:      Any			=					0.0

			_lowercase							:      Tuple			=					special_cos_dist - self.special_care_embeds_weights + adjustment
			# special_scores = special_scores.round(decimals=3)
			_lowercase							:      Dict			=					torch.any(special_scores > 0							,dim=1					)
			_lowercase							:      Any			=					special_care * 0.01
			_lowercase							:      Optional[int]			=					special_adjustment.unsqueeze(1					).expand(-1							,cos_dist.shape[1]					)

			_lowercase							:      Optional[Any]			=					(cos_dist - self.concept_embeds_weights) + special_adjustment
			# concept_scores = concept_scores.round(decimals=3)
			_lowercase							:      Optional[int]			=					torch.any(concept_scores > 0							,dim=1					)

			_lowercase							:      Tuple			=					0.0  # black image

			return images, has_nsfw_concepts



