





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

from ...utils import logging


A_     :   Tuple												=     logging.get_logger(__name__)





def    __UpperCamelCase      (    a,     a) ->Any:
					lowerCamelCase__       =       nn.functional.normalize(a)
					lowerCamelCase__       =       nn.functional.normalize(a)
					return torch.mm(a,     normalized_text_embeds.t())







class SCREAMING_SNAKE_CASE_ (					lowercase_   ):





					"""simple docstring"""


					A__				 =    CLIPConfig

					A__				 =    ["CLIPEncoderLayer"]





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

										lowerCamelCase__       =       CLIPVisionModel(config.vision_config	)
										lowerCamelCase__       =       nn.Linear(config.vision_config.hidden_size	,  config.projection_dim	,  bias=_lowerCAmelCase	)

										lowerCamelCase__       =       nn.Parameter(torch.ones(17	,  config.projection_dim	)	,  requires_grad=_lowerCAmelCase	)
										lowerCamelCase__       =       nn.Parameter(torch.ones(3	,  config.projection_dim	)	,  requires_grad=_lowerCAmelCase	)

										lowerCamelCase__       =       nn.Parameter(torch.ones(17	)	,  requires_grad=_lowerCAmelCase	)
										lowerCamelCase__       =       nn.Parameter(torch.ones(3	)	,  requires_grad=_lowerCAmelCase	)





					@torch.no_grad()
					def 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	):
										lowerCamelCase__       =       self.vision_model(_lowerCAmelCase	)[1]  # pooled_output
										lowerCamelCase__       =       self.visual_projection(_lowerCAmelCase	)

										# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
										lowerCamelCase__       =       cosine_distance(_lowerCAmelCase	,  self.special_care_embeds	).cpu().float().numpy()
										lowerCamelCase__       =       cosine_distance(_lowerCAmelCase	,  self.concept_embeds	).cpu().float().numpy()

										lowerCamelCase__       =       []
										lowerCamelCase__       =       image_embeds.shape[0]
										for i in range(_lowerCAmelCase	):
															lowerCamelCase__       =       {"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
															lowerCamelCase__       =       0.0

															for concept_idx in range(len(special_cos_dist[0]	)	):
																				lowerCamelCase__       =       special_cos_dist[i][concept_idx]
																				lowerCamelCase__       =       self.special_care_embeds_weights[concept_idx].item()
																				lowerCamelCase__       =       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]}	)
																									lowerCamelCase__       =       0.01

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

															result.append(_lowerCAmelCase	)

										lowerCamelCase__       =       [len(res["bad_concepts"]	) > 0 for res in result]

										return images, has_nsfw_concepts






					@torch.no_grad()
					def 					__magic_name__ ( self	,  _lowerCAmelCase	,  _lowerCAmelCase	):
										lowerCamelCase__       =       self.vision_model(_lowerCAmelCase	)[1]  # pooled_output
										lowerCamelCase__       =       self.visual_projection(_lowerCAmelCase	)

										lowerCamelCase__       =       cosine_distance(_lowerCAmelCase	,  self.special_care_embeds	)
										lowerCamelCase__       =       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
										lowerCamelCase__       =       0.0

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

										lowerCamelCase__       =       (cos_dist - self.concept_embeds_weights) + special_adjustment
										# concept_scores = concept_scores.round(decimals=3)
										lowerCamelCase__       =       torch.any(concept_scores > 0	,  dim=1	)

										return images, has_nsfw_concepts








from typing import TYPE_CHECKING

from ...utils import _LazyModule


A_												=     {"tokenization_byt5": ["ByT5Tokenizer"]}


if TYPE_CHECKING:
						from .tokenization_byta import ByTaTokenizer
else:
						import sys

						A_												=     _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

