


import os
import unittest

from transformers import MobileBertTokenizer, MobileBertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english
@require_tokenizers
class        _lowercase      (			A__						,			unittest.TestCase       ):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE__				:			Dict						=		MobileBertTokenizer
				SCREAMING_SNAKE_CASE__				:			Tuple						=		MobileBertTokenizerFast
				SCREAMING_SNAKE_CASE__				:			int						=		True
				SCREAMING_SNAKE_CASE__				:			Tuple						=		True
				SCREAMING_SNAKE_CASE__				:			List[Any]						=		filter_non_english
				SCREAMING_SNAKE_CASE__				:			List[Any]						=		'''google/mobilebert-uncased'''


				def 		__magic_name__(       self			:Optional[Any]	)		->			Tuple:
										super().setUp()

										__SCREAMING_SNAKE_CASE						:     Any					=		[
										    '''[UNK]''',
										    '''[CLS]''',
										    '''[SEP]''',
										    '''[PAD]''',
										    '''[MASK]''',
										    '''want''',
										    '''##want''',
										    '''##ed''',
										    '''wa''',
										    '''un''',
										    '''runn''',
										    '''##ing''',
										    ''',''',
										    '''low''',
										    '''lowest''',
										]
										__SCREAMING_SNAKE_CASE						:     Tuple					=		os.path.join(self.tmpdirname			,			VOCAB_FILES_NAMES['''vocab_file''']	)
										with open(self.vocab_file			,			'''w'''			,			encoding='''utf-8'''	) as vocab_writer:
																vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]	)	)

										__SCREAMING_SNAKE_CASE						:     int					=		[
										    (tokenizer_def[0], self.pre_trained_model_path, tokenizer_def[2])  # else the 'google/' prefix is stripped
										    for tokenizer_def in self.tokenizers_list
										]


				def 		__magic_name__(       self			:int			,			lowerCAmelCase__			:List[str]	)		->			Union[str, Any]:
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		'''UNwant\u00E9d,running'''
										__SCREAMING_SNAKE_CASE						:     Any					=		'''unwanted, running'''
										return input_text, output_text


				def 		__magic_name__(       self			:List[str]	)		->			int:
										__SCREAMING_SNAKE_CASE						:     int					=		self.tokenizer_class(self.vocab_file	)

										__SCREAMING_SNAKE_CASE						:     List[str]					=		tokenizer.tokenize('''UNwant\u00E9d,running'''	)
										self.assertListEqual(lowerCAmelCase__			,			['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']	)
										self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase__	)			,			[9, 6, 7, 12, 10, 11]	)


				def 		__magic_name__(       self			:Optional[Any]	)		->			Tuple:
										if not self.test_rust_tokenizer:
																return

										__SCREAMING_SNAKE_CASE						:     str					=		self.get_tokenizer()
										__SCREAMING_SNAKE_CASE						:     Tuple					=		self.get_rust_tokenizer()

										__SCREAMING_SNAKE_CASE						:     Dict					=		'''UNwant\u00E9d,running'''

										__SCREAMING_SNAKE_CASE						:     Tuple					=		tokenizer.tokenize(lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Tuple					=		rust_tokenizer.tokenize(lowerCAmelCase__	)
										self.assertListEqual(lowerCAmelCase__			,			lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     int					=		tokenizer.encode(lowerCAmelCase__			,			add_special_tokens=lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     str					=		rust_tokenizer.encode(lowerCAmelCase__			,			add_special_tokens=lowerCAmelCase__	)
										self.assertListEqual(lowerCAmelCase__			,			lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		self.get_rust_tokenizer()
										__SCREAMING_SNAKE_CASE						:     Any					=		tokenizer.encode(lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     List[str]					=		rust_tokenizer.encode(lowerCAmelCase__	)
										self.assertListEqual(lowerCAmelCase__			,			lowerCAmelCase__	)

										# With lower casing
										__SCREAMING_SNAKE_CASE						:     int					=		self.get_tokenizer(do_lower_case=lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		self.get_rust_tokenizer(do_lower_case=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Any					=		'''UNwant\u00E9d,running'''

										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		tokenizer.tokenize(lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Dict					=		rust_tokenizer.tokenize(lowerCAmelCase__	)
										self.assertListEqual(lowerCAmelCase__			,			lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     List[str]					=		tokenizer.encode(lowerCAmelCase__			,			add_special_tokens=lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		rust_tokenizer.encode(lowerCAmelCase__			,			add_special_tokens=lowerCAmelCase__	)
										self.assertListEqual(lowerCAmelCase__			,			lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Dict					=		self.get_rust_tokenizer()
										__SCREAMING_SNAKE_CASE						:     List[str]					=		tokenizer.encode(lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Dict					=		rust_tokenizer.encode(lowerCAmelCase__	)
										self.assertListEqual(lowerCAmelCase__			,			lowerCAmelCase__	)


				def 		__magic_name__(       self			:List[str]	)		->			List[Any]:
										__SCREAMING_SNAKE_CASE						:     int					=		BasicTokenizer()

										self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz'''	)			,			['''ah''', '''\u535A''', '''\u63A8''', '''zz''']	)


				def 		__magic_name__(       self			:List[str]	)		->			str:
										__SCREAMING_SNAKE_CASE						:     int					=		BasicTokenizer(do_lower_case=lowerCAmelCase__	)

										self.assertListEqual(
										    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''	)			,			['''hello''', '''!''', '''how''', '''are''', '''you''', '''?''']	)
										self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''	)			,			['''hello''']	)


				def 		__magic_name__(       self			:Optional[int]	)		->			int:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		BasicTokenizer(do_lower_case=lowerCAmelCase__			,			strip_accents=lowerCAmelCase__	)

										self.assertListEqual(
										    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''	)			,			['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?''']	)
										self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''	)			,			['''h\u00E9llo''']	)


				def 		__magic_name__(       self			:Tuple	)		->			Any:
										__SCREAMING_SNAKE_CASE						:     List[str]					=		BasicTokenizer(do_lower_case=lowerCAmelCase__			,			strip_accents=lowerCAmelCase__	)

										self.assertListEqual(
										    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''	)			,			['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']	)
										self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''	)			,			['''hello''']	)


				def 		__magic_name__(       self			:Optional[int]	)		->			Optional[int]:
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		BasicTokenizer(do_lower_case=lowerCAmelCase__	)

										self.assertListEqual(
										    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''	)			,			['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']	)
										self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''	)			,			['''hello''']	)


				def 		__magic_name__(       self			:Any	)		->			Dict:
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		BasicTokenizer(do_lower_case=lowerCAmelCase__	)

										self.assertListEqual(
										    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''	)			,			['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']	)


				def 		__magic_name__(       self			:Union[str, Any]	)		->			Union[str, Any]:
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		BasicTokenizer(do_lower_case=lowerCAmelCase__			,			strip_accents=lowerCAmelCase__	)

										self.assertListEqual(
										    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''	)			,			['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']	)


				def 		__magic_name__(       self			:Tuple	)		->			Any:
										__SCREAMING_SNAKE_CASE						:     int					=		BasicTokenizer(do_lower_case=lowerCAmelCase__			,			strip_accents=lowerCAmelCase__	)

										self.assertListEqual(
										    tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''	)			,			['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']	)


				def 		__magic_name__(       self			:Optional[Any]	)		->			List[Any]:
										__SCREAMING_SNAKE_CASE						:     Dict					=		BasicTokenizer(do_lower_case=lowerCAmelCase__			,			never_split=['''[UNK]''']	)

										self.assertListEqual(
										    tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]'''	)			,			['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]''']	)


				def 		__magic_name__(       self			:int	)		->			List[str]:
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

										__SCREAMING_SNAKE_CASE						:     List[str]					=		{}
										for i, token in enumerate(lowerCAmelCase__	):
																__SCREAMING_SNAKE_CASE						:     List[str]					=		i
										__SCREAMING_SNAKE_CASE						:     Tuple					=		WordpieceTokenizer(vocab=lowerCAmelCase__			,			unk_token='''[UNK]'''	)

										self.assertListEqual(tokenizer.tokenize(''''''	)			,			[]	)

										self.assertListEqual(tokenizer.tokenize('''unwanted running'''	)			,			['''un''', '''##want''', '''##ed''', '''runn''', '''##ing''']	)

										self.assertListEqual(tokenizer.tokenize('''unwantedX running'''	)			,			['''[UNK]''', '''runn''', '''##ing''']	)


				def 		__magic_name__(       self			:Optional[Any]	)		->			List[Any]:
										self.assertTrue(_is_whitespace(''' '''	)	)
										self.assertTrue(_is_whitespace('''\t'''	)	)
										self.assertTrue(_is_whitespace('''\r'''	)	)
										self.assertTrue(_is_whitespace('''\n'''	)	)
										self.assertTrue(_is_whitespace('''\u00A0'''	)	)

										self.assertFalse(_is_whitespace('''A'''	)	)
										self.assertFalse(_is_whitespace('''-'''	)	)


				def 		__magic_name__(       self			:Optional[int]	)		->			Optional[int]:
										self.assertTrue(_is_control('''\u0005'''	)	)

										self.assertFalse(_is_control('''A'''	)	)
										self.assertFalse(_is_control(''' '''	)	)
										self.assertFalse(_is_control('''\t'''	)	)
										self.assertFalse(_is_control('''\r'''	)	)


				def 		__magic_name__(       self			:List[Any]	)		->			Dict:
										self.assertTrue(_is_punctuation('''-'''	)	)
										self.assertTrue(_is_punctuation('''$'''	)	)
										self.assertTrue(_is_punctuation('''`'''	)	)
										self.assertTrue(_is_punctuation('''.'''	)	)

										self.assertFalse(_is_punctuation('''A'''	)	)
										self.assertFalse(_is_punctuation(''' '''	)	)


				def 		__magic_name__(       self			:List[str]	)		->			Optional[Any]:
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		self.get_tokenizer()
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		self.get_rust_tokenizer()

										# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
										self.assertListEqual([tokenizer.tokenize(lowerCAmelCase__	) for t in ['''Test''', '''\xad''', '''test''']]			,			[['''[UNK]'''], [], ['''[UNK]''']]	)

										self.assertListEqual(
										    [rust_tokenizer.tokenize(lowerCAmelCase__	) for t in ['''Test''', '''\xad''', '''test''']]			,			[['''[UNK]'''], [], ['''[UNK]''']]	)


				@slow
				def 		__magic_name__(       self			:Tuple	)		->			List[Any]:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		self.tokenizer_class.from_pretrained('''google/mobilebert-uncased'''	)

										__SCREAMING_SNAKE_CASE						:     List[str]					=		tokenizer.encode('''sequence builders'''			,			add_special_tokens=lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Any					=		tokenizer.encode('''multi-sequence build'''			,			add_special_tokens=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     List[str]					=		tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Dict					=		tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__			,			lowerCAmelCase__	)

										assert encoded_sentence == [101] + text + [102]
										assert encoded_pair == [101] + text + [102] + text_a + [102]


				def 		__magic_name__(       self			:Optional[Any]	)		->			int:
										for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''	):
																						__SCREAMING_SNAKE_CASE						:     int					=		self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__			,			**lowerCAmelCase__	)

																						__SCREAMING_SNAKE_CASE						:     Dict					=		f'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
																						__SCREAMING_SNAKE_CASE						:     List[str]					=		tokenizer_r.encode_plus(
																						    lowerCAmelCase__			,			return_attention_mask=lowerCAmelCase__			,			return_token_type_ids=lowerCAmelCase__			,			return_offsets_mapping=lowerCAmelCase__			,			add_special_tokens=lowerCAmelCase__			,			)

																						__SCREAMING_SNAKE_CASE						:     int					=		tokenizer_r.do_lower_case if hasattr(lowerCAmelCase__			,			'''do_lower_case'''	) else False
																						__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		(
																						    [
																						        ((0, 0), tokenizer_r.cls_token),
																						        ((0, 1), '''A'''),
																						        ((1, 2), ''','''),
																						        ((3, 5), '''na'''),
																						        ((5, 6), '''##ï'''),
																						        ((6, 8), '''##ve'''),
																						        ((9, 15), tokenizer_r.mask_token),
																						        ((16, 21), '''Allen'''),
																						        ((21, 23), '''##NL'''),
																						        ((23, 24), '''##P'''),
																						        ((25, 33), '''sentence'''),
																						        ((33, 34), '''.'''),
																						        ((0, 0), tokenizer_r.sep_token),
																						    ]
																						    if not do_lower_case
																						    else [
																						        ((0, 0), tokenizer_r.cls_token),
																						        ((0, 1), '''a'''),
																						        ((1, 2), ''','''),
																						        ((3, 8), '''naive'''),
																						        ((9, 15), tokenizer_r.mask_token),
																						        ((16, 21), '''allen'''),
																						        ((21, 23), '''##nl'''),
																						        ((23, 24), '''##p'''),
																						        ((25, 33), '''sentence'''),
																						        ((33, 34), '''.'''),
																						        ((0, 0), tokenizer_r.sep_token),
																						    ]
																						)

																						self.assertEqual(
																						    [e[1] for e in expected_results]			,			tokenizer_r.convert_ids_to_tokens(tokens['''input_ids''']	)	)
																						self.assertEqual([e[0] for e in expected_results]			,			tokens['''offset_mapping''']	)



				def 		__magic_name__(       self			:Dict	)		->			List[str]:
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		['''的''', '''人''', '''有''']
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		''''''.join(lowerCAmelCase__	)
										for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''	):
																						__SCREAMING_SNAKE_CASE						:     Any					=		True
																						__SCREAMING_SNAKE_CASE						:     List[Any]					=		self.tokenizer_class.from_pretrained(lowerCAmelCase__			,			**lowerCAmelCase__	)
																						__SCREAMING_SNAKE_CASE						:     Any					=		self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__			,			**lowerCAmelCase__	)

																						__SCREAMING_SNAKE_CASE						:     Any					=		tokenizer_p.encode(lowerCAmelCase__			,			add_special_tokens=lowerCAmelCase__	)
																						__SCREAMING_SNAKE_CASE						:     Dict					=		tokenizer_r.encode(lowerCAmelCase__			,			add_special_tokens=lowerCAmelCase__	)

																						__SCREAMING_SNAKE_CASE						:     int					=		tokenizer_r.convert_ids_to_tokens(lowerCAmelCase__	)
																						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		tokenizer_p.convert_ids_to_tokens(lowerCAmelCase__	)

																						# it is expected that each Chinese character is not preceded by "##"
																						self.assertListEqual(lowerCAmelCase__			,			lowerCAmelCase__	)
																						self.assertListEqual(lowerCAmelCase__			,			lowerCAmelCase__	)

																						__SCREAMING_SNAKE_CASE						:     Dict					=		False
																						__SCREAMING_SNAKE_CASE						:     Dict					=		self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__			,			**lowerCAmelCase__	)
																						__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		self.tokenizer_class.from_pretrained(lowerCAmelCase__			,			**lowerCAmelCase__	)

																						__SCREAMING_SNAKE_CASE						:     Optional[int]					=		tokenizer_r.encode(lowerCAmelCase__			,			add_special_tokens=lowerCAmelCase__	)
																						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		tokenizer_p.encode(lowerCAmelCase__			,			add_special_tokens=lowerCAmelCase__	)

																						__SCREAMING_SNAKE_CASE						:     Dict					=		tokenizer_r.convert_ids_to_tokens(lowerCAmelCase__	)
																						__SCREAMING_SNAKE_CASE						:     Optional[int]					=		tokenizer_p.convert_ids_to_tokens(lowerCAmelCase__	)

																						# it is expected that only the first Chinese character is not preceded by "##".
																						__SCREAMING_SNAKE_CASE						:     Tuple					=		[
																						    f'''##{token}''' if idx != 0 else token for idx, token in enumerate(lowerCAmelCase__	)
																						]
																						self.assertListEqual(lowerCAmelCase__			,			lowerCAmelCase__	)
																						self.assertListEqual(lowerCAmelCase__			,			lowerCAmelCase__	)




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

from ...utils import logging


__lowerCAmelCase	: Dict  				=logging.get_logger(__name__)


def        _UpperCamelCase							(      lowercase__    ,       lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     List[Any]					=		nn.functional.normalize(lowercase__      )
						__SCREAMING_SNAKE_CASE						:     Tuple					=		nn.functional.normalize(lowercase__      )
						return torch.mm(lowercase__    ,       normalized_text_embeds.t()      )
class        _lowercase      (			A__       ):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE__				:			Optional[Any]						=		CLIPConfig

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


				def __init__(       self			:str			,			lowerCAmelCase__			:CLIPConfig	)		->			Tuple:
										super().__init__(lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		CLIPVisionModel(config.vision_config	)
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		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						:     Optional[Any]					=		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						:     str					=		nn.Parameter(torch.ones(3	)			,			requires_grad=lowerCAmelCase__	)


				@torch.no_grad()
				def 		__magic_name__(       self			:Optional[int]			,			lowerCAmelCase__			:int			,			lowerCAmelCase__			:Optional[int]	)		->			Dict:
										__SCREAMING_SNAKE_CASE						:     int					=		self.vision_model(lowerCAmelCase__	)[1]  # pooled_output
										__SCREAMING_SNAKE_CASE						:     Optional[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						:     Optional[Any]					=		cosine_distance(lowerCAmelCase__			,			self.special_care_embeds	).cpu().float().numpy()
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		cosine_distance(lowerCAmelCase__			,			self.concept_embeds	).cpu().float().numpy()

										__SCREAMING_SNAKE_CASE						:     List[Any]					=		[]
										__SCREAMING_SNAKE_CASE						:     List[Any]					=		image_embeds.shape[0]
										for i in range(lowerCAmelCase__	):
																__SCREAMING_SNAKE_CASE						:     Optional[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
																__SCREAMING_SNAKE_CASE						:     List[Any]					=		0.0

																for concept_idx in range(len(special_cos_dist[0]	)	):
																						__SCREAMING_SNAKE_CASE						:     List[str]					=		special_cos_dist[i][concept_idx]
																						__SCREAMING_SNAKE_CASE						:     Any					=		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						:     Union[str, Any]					=		0.01

																for concept_idx in range(len(cos_dist[0]	)	):
																						__SCREAMING_SNAKE_CASE						:     int					=		cos_dist[i][concept_idx]
																						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		self.concept_embeds_weights[concept_idx].item()
																						__SCREAMING_SNAKE_CASE						:     Tuple					=		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						:     List[str]					=		[len(res['''bad_concepts''']	) > 0 for res in result]

										return images, has_nsfw_concepts



				@torch.no_grad()
				def 		__magic_name__(       self			:Optional[int]			,			lowerCAmelCase__			:torch.FloatTensor			,			lowerCAmelCase__			:torch.FloatTensor	)		->			Any:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		self.vision_model(lowerCAmelCase__	)[1]  # pooled_output
										__SCREAMING_SNAKE_CASE						:     List[str]					=		self.visual_projection(lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     Dict					=		cosine_distance(lowerCAmelCase__			,			self.special_care_embeds	)
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		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						:     List[Any]					=		0.0

										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		special_cos_dist - self.special_care_embeds_weights + adjustment
										# special_scores = special_scores.round(decimals=3)
										__SCREAMING_SNAKE_CASE						:     List[str]					=		torch.any(special_scores > 0			,			dim=1	)
										__SCREAMING_SNAKE_CASE						:     List[str]					=		special_care * 0.01
										__SCREAMING_SNAKE_CASE						:     int					=		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
