



'''simple docstring'''



from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

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

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import (
							    AutoTokenizer,
							    TFAutoModelForCausalLM,
							    TFAutoModelForSeqaSeqLM,
							    TFAutoModelForSpeechSeqaSeq,
							    TFAutoModelForVisionaSeq,
							    TFBartForConditionalGeneration,
							    TFLogitsProcessorList,
							    TFMinLengthLogitsProcessor,
							    tf_top_k_top_p_filtering,
							)

if is_tensorflow_text_available():
							import tensorflow_text as text
@require_tf
class 						lowerCamelCase_				(       unittest.TestCase      ):







						def        __lowercase     (	self :   List[str]					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Any         =      tf.convert_to_tensor(
													    [
													        [
													            8.222_0991,  # 3rd highest value; idx. 0
													            -0.562_0044,
													            5.2322_9752,
													            4.038_6393,
													            -6.879_8378,
													            -0.5478_5802,
													            -3.201_2153,
													            2.9277_7176,
													            1.8817_1953,
													            7.3534_1276,  # 5th highest value; idx. 9
													            8.4320_7833,  # 2nd highest value; idx. 10
													            -9.8571_1836,
													            -5.9620_9236,
													            -1.1303_9161,
													            -7.111_5294,
													            -0.836_9633,
													            -5.318_6408,
													            7.0642_7407,
													            0.8136_9344,
													            -0.8202_3817,
													            -5.917_9796,
													            0.5881_3443,
													            -6.9977_8438,
													            4.7155_1189,
													            -0.1877_1637,
													            7.4402_0759,  # 4th highest value; idx. 25
													            9.3845_0987,  # 1st highest value; idx. 26
													            2.1266_2941,
													            -9.3256_2038,
													            2.3565_2522,
													        ],  # cummulative prob of 5 highest values <= 0.6
													        [
													            0.5842_5518,
													            4.5313_9238,
													            -5.5751_0464,
													            -6.2803_0699,
													            -7.1952_9503,
													            -4.0212_2551,
													            1.3933_7037,
													            -6.0670_7057,
													            1.5948_0517,
													            -9.64_3119,
													            0.0390_7799,
													            0.6723_1762,
													            -8.8820_6726,
													            6.2711_5922,  # 4th highest value; idx. 13
													            2.2852_0723,
													            4.8276_7506,
													            4.3042_1368,
													            8.827_5313,  # 2nd highest value; idx. 17
													            5.4402_9958,  # 5th highest value; idx. 18
													            -4.473_5794,
													            7.3857_9536,  # 3rd highest value; idx. 20
													            -2.9105_1663,
													            2.6194_6077,
													            -2.567_4762,
													            -9.4895_9302,
													            -4.0292_2645,
													            -1.3541_6918,
													            9.6770_2323,  # 1st highest value; idx. 27
													            -5.8947_8553,
													            1.8537_0467,
													        ],  # cummulative prob of 5 highest values <= 0.6
													    ]					,     dtype=tf.floataa					,     )

													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      tf.convert_to_tensor(
													    [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]					,     dtype=tf.intaa					,     )  # expected non filtered idx as noted above

													SCREAMING_SNAKE_CASE       :   List[str]         =      tf.convert_to_tensor(
													    [8.22_2099, 7.353_4126, 8.43_2078, 7.440_2075, 9.3_8451, 6.27_1159, 8.82_7531, 5.440_2995, 7.385_7956, 9.67_7023]					,     dtype=tf.floataa					,     )  # expected non filtered values as noted above

													SCREAMING_SNAKE_CASE       :   List[Any]         =      tf_top_k_top_p_filtering(lowerCAmelCase__					,     top_k=10					,     top_p=0.6					,     min_tokens_to_keep=4					)

													SCREAMING_SNAKE_CASE       :   List[Any]         =      output[output != -float('''inf'''					)]
													SCREAMING_SNAKE_CASE       :   Any         =      tf.cast(
													    tf.where(tf.not_equal(lowerCAmelCase__					,     tf.constant(-float('''inf'''					)					,     dtype=tf.floataa					)					)					)					,     dtype=tf.intaa					,     )

													tf.debugging.assert_near(lowerCAmelCase__					,     lowerCAmelCase__					,     rtol=1e-12					)
													tf.debugging.assert_equal(lowerCAmelCase__					,     lowerCAmelCase__					)


@require_tf
class 						lowerCamelCase_				(       unittest.TestCase     ,					snake_case_      ):
						# setting framework_dependent_parameters needs to be gated, just like its contents' imports
						if is_tf_available():
												_lowerCAmelCase  : List[Any]						  =					{
												    'AutoModelForCausalLM': TFAutoModelForCausalLM,
												    'AutoModelForSpeechSeq2Seq': TFAutoModelForSpeechSeqaSeq,
												    'AutoModelForSeq2SeqLM': TFAutoModelForSeqaSeqLM,
												    'AutoModelForVision2Seq': TFAutoModelForVisionaSeq,
												    'LogitsProcessorList': TFLogitsProcessorList,
												    'MinLengthLogitsProcessor': TFMinLengthLogitsProcessor,
												    'create_tensor_fn': tf.convert_to_tensor,
												    'floats_tensor': floats_tensor,
												    'return_tensors': 'tf',
												}







						@slow
						def        __lowercase     (	self :   Tuple					):

													"""simple docstring"""
													# TF-only test: tf.saved_model export
													SCREAMING_SNAKE_CASE       :   Any         =      TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''					)
													SCREAMING_SNAKE_CASE       :   Tuple         =      2
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      2
													class 						lowerCamelCase_				(       tf.Module      ):







																			def __init__(	self :   Tuple					,     lowerCAmelCase__ :   Optional[Any]					):

																										"""simple docstring"""
																										super(lowerCAmelCase__					,     self					).__init__()
																										SCREAMING_SNAKE_CASE       :   List[str]         =      model







																			@tf.function(
																			    input_signature=(
																			        tf.TensorSpec((None, input_length)					,     tf.intaa					,     name='''input_ids'''					),
																			        tf.TensorSpec((None, input_length)					,     tf.intaa					,     name='''attention_mask'''					),
																			    )					,     jit_compile=lowerCAmelCase__					,     )
																			def        __lowercase     (	self :   Optional[int]					,     lowerCAmelCase__ :   Any					,     lowerCAmelCase__ :   str					):

																										"""simple docstring"""
																										SCREAMING_SNAKE_CASE       :   Optional[Any]         =      self.model.generate(
																										    input_ids=lowerCAmelCase__					,     attention_mask=lowerCAmelCase__					,     max_new_tokens=lowerCAmelCase__					,     return_dict_in_generate=lowerCAmelCase__					,     )
																										return {"sequences": outputs["sequences"]}


													SCREAMING_SNAKE_CASE       :   List[str]         =      [[2, 0], [1_02, 1_03]]
													SCREAMING_SNAKE_CASE       :   List[Any]         =      [[1, 0], [1, 1]]
													SCREAMING_SNAKE_CASE       :   int         =      DummyModel(model=lowerCAmelCase__					)
													with tempfile.TemporaryDirectory() as tmp_dir:
																				tf.saved_model.save(lowerCAmelCase__					,     lowerCAmelCase__					,     signatures={'''serving_default''': dummy_model.serving}					)
																				SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      tf.saved_model.load(lowerCAmelCase__					).signatures['''serving_default''']
																				for batch_size in range(1					,     len(lowerCAmelCase__					) + 1					):
																											SCREAMING_SNAKE_CASE       :   List[str]         =      {
																											    '''input_ids''': tf.constant(dummy_input_ids[:batch_size]					),
																											    '''attention_mask''': tf.constant(dummy_attention_masks[:batch_size]					),
																											}
																											SCREAMING_SNAKE_CASE       :   Any         =      serving_func(**lowerCAmelCase__					)['''sequences''']
																											SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      test_model.generate(**lowerCAmelCase__					,     max_new_tokens=lowerCAmelCase__					)
																											tf.debugging.assert_equal(lowerCAmelCase__					,     lowerCAmelCase__					)







						@slow
						def        __lowercase     (	self :   Tuple					):

													"""simple docstring"""
													# TF-only test: tf.saved_model export
													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''					)
													SCREAMING_SNAKE_CASE       :   int         =      1
													SCREAMING_SNAKE_CASE       :   Dict         =      2
													class 						lowerCamelCase_				(       tf.Module      ):







																			def __init__(	self :   Optional[Any]					,     lowerCAmelCase__ :   Optional[Any]					):

																										"""simple docstring"""
																										super(lowerCAmelCase__					,     self					).__init__()
																										SCREAMING_SNAKE_CASE       :   Tuple         =      model







																			@tf.function(
																			    input_signature=(
																			        tf.TensorSpec((batch_size, None)					,     tf.intaa					,     name='''input_ids'''					),
																			        tf.TensorSpec((batch_size, None)					,     tf.intaa					,     name='''attention_mask'''					),
																			    )					,     jit_compile=lowerCAmelCase__					,     )
																			def        __lowercase     (	self :   Optional[Any]					,     lowerCAmelCase__ :   int					,     lowerCAmelCase__ :   str					):

																										"""simple docstring"""
																										SCREAMING_SNAKE_CASE       :   Optional[int]         =      self.model.generate(
																										    input_ids=lowerCAmelCase__					,     attention_mask=lowerCAmelCase__					,     max_new_tokens=lowerCAmelCase__					,     return_dict_in_generate=lowerCAmelCase__					,     )
																										return {"sequences": outputs["sequences"]}


													SCREAMING_SNAKE_CASE       :   Tuple         =      [[2], [1_02, 1_03]]
													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      [[1], [1, 1]]
													SCREAMING_SNAKE_CASE       :   int         =      DummyModel(model=lowerCAmelCase__					)
													with tempfile.TemporaryDirectory() as tmp_dir:
																				tf.saved_model.save(lowerCAmelCase__					,     lowerCAmelCase__					,     signatures={'''serving_default''': dummy_model.serving}					)
																				SCREAMING_SNAKE_CASE       :   List[str]         =      tf.saved_model.load(lowerCAmelCase__					).signatures['''serving_default''']
																				for input_row in range(len(lowerCAmelCase__					)					):
																											SCREAMING_SNAKE_CASE       :   Tuple         =      {
																											    '''input_ids''': tf.constant([dummy_input_ids[input_row]]					),
																											    '''attention_mask''': tf.constant([dummy_attention_masks[input_row]]					),
																											}
																											SCREAMING_SNAKE_CASE       :   Any         =      serving_func(**lowerCAmelCase__					)['''sequences''']
																											SCREAMING_SNAKE_CASE       :   str         =      test_model.generate(**lowerCAmelCase__					,     max_new_tokens=lowerCAmelCase__					)
																											tf.debugging.assert_equal(lowerCAmelCase__					,     lowerCAmelCase__					)







						@slow
						@require_tensorflow_text
						def        __lowercase     (	self :   int					):

													"""simple docstring"""
													# TF-only test: tf.saved_model export
													with tempfile.TemporaryDirectory() as tmp_dir:
																				# file needed to load the TF tokenizer
																				hf_hub_download(repo_id='''google/flan-t5-small'''					,     filename='''spiece.model'''					,     local_dir=lowerCAmelCase__					)
																				class 						lowerCamelCase_				(       tf.keras.layers.Layer      ):







																										def __init__(	self :   str					):

																																	"""simple docstring"""
																																	super().__init__()
																																	SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      text.SentencepieceTokenizer(
																																	    model=tf.io.gfile.GFile(os.path.join(lowerCAmelCase__					,     '''spiece.model'''					)					,     '''rb'''					).read()					)
																																	SCREAMING_SNAKE_CASE       :   str         =      TFAutoModelForSeqaSeqLM.from_pretrained('''hf-internal-testing/tiny-random-t5'''					)







																										def        __lowercase     (	self :   List[str]					,     lowerCAmelCase__ :   Any					,     *lowerCAmelCase__ :   Dict					,     **lowerCAmelCase__ :   List[str]					):

																																	"""simple docstring"""
																																	SCREAMING_SNAKE_CASE       :   Any         =      self.tokenizer.tokenize(lowerCAmelCase__					)
																																	SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       :   str         =      text.pad_model_inputs(
																																	    lowerCAmelCase__					,     max_seq_length=64					,     pad_value=self.model.config.pad_token_id					)
																																	SCREAMING_SNAKE_CASE       :   int         =      self.model.generate(input_ids=lowerCAmelCase__					,     attention_mask=lowerCAmelCase__					)
																																	return self.tokenizer.detokenize(lowerCAmelCase__					)


																				SCREAMING_SNAKE_CASE       :   Any         =      CompleteSentenceTransformer()
																				SCREAMING_SNAKE_CASE       :   Any         =      tf.keras.layers.Input(shape=(1,)					,     dtype=tf.string					,     name='''inputs'''					)
																				SCREAMING_SNAKE_CASE       :   str         =      complete_model(lowerCAmelCase__					)
																				SCREAMING_SNAKE_CASE       :   Tuple         =      tf.keras.Model(lowerCAmelCase__					,     lowerCAmelCase__					)
																				keras_model.save(lowerCAmelCase__					)







						def        __lowercase     (	self :   Tuple					):

													"""simple docstring"""
													# Has PT equivalent: this test relies on random sampling
													SCREAMING_SNAKE_CASE       :   Dict         =      {
													    '''do_sample''': True,
													    '''num_beams''': 1,
													    '''top_p''': 0.7,
													    '''top_k''': 10,
													    '''temperature''': 0.7,
													}
													SCREAMING_SNAKE_CASE       :   Dict         =      14

													SCREAMING_SNAKE_CASE       :   Optional[int]         =      AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''					)
													SCREAMING_SNAKE_CASE       :   Any         =      '''Hello, my dog is cute and'''
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      tokenizer(lowerCAmelCase__					,     return_tensors='''tf'''					)
													SCREAMING_SNAKE_CASE       :   List[str]         =      TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''					)

													SCREAMING_SNAKE_CASE       :   int         =      6_38
													# forces the generation to happen on CPU, to avoid GPU-related quirks
													with tf.device(''':/CPU:0'''					):
																				tf.random.set_seed(0					)
																				SCREAMING_SNAKE_CASE       :   Any         =      model.generate(**lowerCAmelCase__					,     eos_token_id=lowerCAmelCase__					,     **lowerCAmelCase__					)
													self.assertTrue(expectation == len(generated_tokens[0]					)					)

													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      [6_38, 1_98]
													with tf.device(''':/CPU:0'''					):
																				tf.random.set_seed(0					)
																				SCREAMING_SNAKE_CASE       :   Dict         =      model.generate(**lowerCAmelCase__					,     eos_token_id=lowerCAmelCase__					,     **lowerCAmelCase__					)
													self.assertTrue(expectation == len(generated_tokens[0]					)					)







						def        __lowercase     (	self :   List[str]					):

													"""simple docstring"""
													# Has PT equivalent: ample use of framework-specific code
													SCREAMING_SNAKE_CASE       :   str         =      AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bart'''					)
													SCREAMING_SNAKE_CASE       :   Tuple         =      '''Hugging Face is a technology company based in New York and Paris.'''
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      bart_tokenizer(lowerCAmelCase__					,     return_tensors='''tf'''					).input_ids
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      TFBartForConditionalGeneration.from_pretrained('''hf-internal-testing/tiny-random-bart'''					)
													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      bart_model.generate(lowerCAmelCase__					).numpy()
													class 						lowerCamelCase_				(       snake_case_      ):







																			def        __lowercase     (	self :   str					,     lowerCAmelCase__ :   Optional[Any]					,     lowerCAmelCase__ :   List[str]=None					,     **lowerCAmelCase__ :   Any					):

																										"""simple docstring"""
																										return super().call(lowerCAmelCase__					,     **lowerCAmelCase__					)


													SCREAMING_SNAKE_CASE       :   Tuple         =      FakeBart.from_pretrained('''hf-internal-testing/tiny-random-bart'''					)
													SCREAMING_SNAKE_CASE       :   Tuple         =      bart_model.generate(lowerCAmelCase__					,     foo='''bar'''					).numpy()
													self.assertTrue(np.array_equal(lowerCAmelCase__					,     lowerCAmelCase__					)					)
													class 						lowerCamelCase_				(       bart_model.model.encoder.__class__      ):







																			def        __lowercase     (	self :   int					,     lowerCAmelCase__ :   Optional[Any]					,     **lowerCAmelCase__ :   Tuple					):

																										"""simple docstring"""
																										return super().call(lowerCAmelCase__					,     **lowerCAmelCase__					)


													SCREAMING_SNAKE_CASE       :   Optional[int]         =      FakeEncoder(bart_model.config					,     bart_model.model.shared					)
													SCREAMING_SNAKE_CASE       :   Any         =      fake_encoder

													# Normal generation still works (the output will be different because the encoder weights are different)
													SCREAMING_SNAKE_CASE       :   List[str]         =      bart_model.generate(lowerCAmelCase__					).numpy()
													with self.assertRaises(lowerCAmelCase__					):
																				# FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
																				bart_model.generate(lowerCAmelCase__					,     foo='''bar'''					)









'''simple docstring'''



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

from ...utils import logging


lowerCAmelCase_  :							int             =    logging.get_logger(__name__)
def        UpperCAmelCase (    A	:					List[Any]       ,		A	:					Optional[int]					):
							SCREAMING_SNAKE_CASE       :   Any         =      nn.functional.normalize(A					)
							SCREAMING_SNAKE_CASE       :   List[str]         =      nn.functional.normalize(A					)
							return torch.mm(A       ,		normalized_text_embeds.t()					)






class 						lowerCamelCase_				(       snake_case_      ):
						_lowerCAmelCase  : Optional[Any]						  =					CLIPConfig

						_lowerCAmelCase  : List[str]						  =					['CLIPEncoderLayer']







						def __init__(	self :   int					,     lowerCAmelCase__ :   CLIPConfig					):

													"""simple docstring"""
													super().__init__(lowerCAmelCase__					)

													SCREAMING_SNAKE_CASE       :   Any         =      CLIPVisionModel(config.vision_config					)
													SCREAMING_SNAKE_CASE       :   List[str]         =      nn.Linear(config.vision_config.hidden_size					,     config.projection_dim					,     bias=lowerCAmelCase__					)

													SCREAMING_SNAKE_CASE       :   Any         =      nn.Parameter(torch.ones(17					,     config.projection_dim					)					,     requires_grad=lowerCAmelCase__					)
													SCREAMING_SNAKE_CASE       :   int         =      nn.Parameter(torch.ones(3					,     config.projection_dim					)					,     requires_grad=lowerCAmelCase__					)

													SCREAMING_SNAKE_CASE       :   Dict         =      nn.Parameter(torch.ones(17					)					,     requires_grad=lowerCAmelCase__					)
													SCREAMING_SNAKE_CASE       :   List[str]         =      nn.Parameter(torch.ones(3					)					,     requires_grad=lowerCAmelCase__					)







						@torch.no_grad()
						def        __lowercase     (	self :   List[str]					,     lowerCAmelCase__ :   List[str]					,     lowerCAmelCase__ :   Optional[Any]					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Any         =      self.vision_model(lowerCAmelCase__					)[1]  # pooled_output
													SCREAMING_SNAKE_CASE       :   Any         =      self.visual_projection(lowerCAmelCase__					)

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

													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      []
													SCREAMING_SNAKE_CASE       :   int         =      image_embeds.shape[0]
													for i in range(lowerCAmelCase__					):
																				SCREAMING_SNAKE_CASE       :   Any         =      {'''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
																				SCREAMING_SNAKE_CASE       :   int         =      0.0

																				for concept_idx in range(len(special_cos_dist[0]					)					):
																											SCREAMING_SNAKE_CASE       :   Optional[int]         =      special_cos_dist[i][concept_idx]
																											SCREAMING_SNAKE_CASE       :   int         =      self.special_care_embeds_weights[concept_idx].item()
																											SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      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]}					)
																																		SCREAMING_SNAKE_CASE       :   Tuple         =      0.01

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

																				result.append(lowerCAmelCase__					)

													SCREAMING_SNAKE_CASE       :   Dict         =      [len(res['''bad_concepts''']					) > 0 for res in result]

													return images, has_nsfw_concepts







						@torch.no_grad()
						def        __lowercase     (	self :   List[str]					,     lowerCAmelCase__ :   torch.FloatTensor					,     lowerCAmelCase__ :   torch.FloatTensor					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      self.vision_model(lowerCAmelCase__					)[1]  # pooled_output
													SCREAMING_SNAKE_CASE       :   List[Any]         =      self.visual_projection(lowerCAmelCase__					)

													SCREAMING_SNAKE_CASE       :   List[str]         =      cosine_distance(lowerCAmelCase__					,     self.special_care_embeds					)
													SCREAMING_SNAKE_CASE       :   List[str]         =      cosine_distance(lowerCAmelCase__					,     self.concept_embeds					)

													# increase this value to create a stronger `nsfw` filter
													# at the cost of increasing the possibility of filtering benign images
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      0.0

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

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

													return images, has_nsfw_concepts




