
from __future__ import annotations

import unittest

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


if is_tf_available():
			import numpy as np
			import tensorflow as tf

			from transformers import TFCamembertModel




@require_tf
@require_sentencepiece
@require_tokenizers
class        _SCREAMING_SNAKE_CASE	( unittest.TestCase		):



	@slow
	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[int]:
					lowerCamelCase_         =     TFCamembertModel.from_pretrained("jplu/tf-camembert-base"					)

					lowerCamelCase_         =     tf.convert_to_tensor(
					    [[5, 121, 11, 660, 16, 730, 25543, 110, 83, 6]]		,    dtype=tf.intaa		,    )  # J'aime le camembert !"

					lowerCamelCase_         =     model(lowercase					)["last_hidden_state"]
					lowerCamelCase_         =     tf.TensorShape((1, 10, 768)					)
					self.assertEqual(output.shape		,    lowercase					)
					# compare the actual values for a slice.
					lowerCamelCase_         =     tf.convert_to_tensor(
					    [[[-0.0_2_5_4, 0.0_2_3_5, 0.1_0_2_7], [0.0_6_0_6, -0.1_8_1_1, -0.0_4_1_8], [-0.1_5_6_1, -0.1_1_2_7, 0.2_6_8_7]]]		,    dtype=tf.floataa		,    )
					# camembert = torch.hub.load('pytorch/fairseq', 'camembert.v0')
					# camembert.eval()
					# expected_slice = roberta.model.forward(input_ids)[0][:, :3, :3].detach()

					self.assertTrue(np.allclose(output[:, :3, :3].numpy()		,    expected_slice.numpy()		,    atol=1e-4					)					)




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

from ...utils import logging


__A							=logging.get_logger(__name__)




class        _SCREAMING_SNAKE_CASE	( snake_case_		):
	lowerCAmelCase__   =					CLIPConfig

	lowerCAmelCase__   =					['CLIPEncoderLayer']



	def __init__(       self		,    lowercase					)							->			int:
					super().__init__(lowercase					)

					lowerCamelCase_         =     CLIPVisionModelWithProjection(config.vision_config					)

					lowerCamelCase_         =     nn.Linear(config.vision_config.projection_dim		,    1					)
					lowerCamelCase_         =     nn.Linear(config.vision_config.projection_dim		,    1					)



	@torch.no_grad()
	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase		,    lowercase=0.5		,    lowercase=0.5					)							->			int:
					lowerCamelCase_         =     self.vision_model(lowercase					)[0]

					lowerCamelCase_         =     self.p_head(lowercase					)
					lowerCamelCase_         =     nsfw_detected.flatten()
					lowerCamelCase_         =     nsfw_detected > p_threshold
					lowerCamelCase_         =     nsfw_detected.tolist()

					if any(lowercase					):
									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."					)

					for idx, nsfw_detected_ in enumerate(lowercase					):
									if nsfw_detected_:
													lowerCamelCase_         =     np.zeros(images[idx].shape					)

					lowerCamelCase_         =     self.w_head(lowercase					)
					lowerCamelCase_         =     watermark_detected.flatten()
					lowerCamelCase_         =     watermark_detected > w_threshold
					lowerCamelCase_         =     watermark_detected.tolist()

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

					for idx, watermark_detected_ in enumerate(lowercase					):
									if watermark_detected_:
													lowerCamelCase_         =     np.zeros(images[idx].shape					)

					return images, nsfw_detected, watermark_detected


