






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

from ...utils import logging


__A          = logging.get_logger(__name__)




def    __A    (   _lowercase    ,	_lowercase       ):

					'''simple docstring'''







					_A									=       nn.functional.normalize(_lowercase       )
					_A									=       nn.functional.normalize(_lowercase       )
					return torch.mm(_lowercase    ,	normalized_text_embeds.t()       )





class   SCREAMING_SNAKE_CASE (       snake_case    ):





							"""simple docstring"""

							A_       =    CLIPConfig

							A_       =    ["CLIPEncoderLayer"]

							def __init__(     self:      Any						,   __A:      CLIPConfig      )			-> Optional[int]:
												super().__init__(__A      )

												_A									=       CLIPVisionModel(config.vision_config      )
												_A									=       nn.Linear(config.vision_config.hidden_size						,   config.projection_dim						,   bias=__A      )

												_A									=       nn.Parameter(torch.ones(17						,   config.projection_dim      )						,   requires_grad=__A      )
												_A									=       nn.Parameter(torch.ones(3						,   config.projection_dim      )						,   requires_grad=__A      )

												_A									=       nn.Parameter(torch.ones(17      )						,   requires_grad=__A      )
												_A									=       nn.Parameter(torch.ones(3      )						,   requires_grad=__A      )

							@torch.no_grad()
							def 					__A       (     self:      Optional[int]						,   __A:      Optional[Any]						,   __A:      Tuple      )			-> str:
												_A									=       self.vision_model(__A      )[1]  # pooled_output
												_A									=       self.visual_projection(__A      )

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

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

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

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

																	result.append(__A      )

												_A									=       [len(res['''bad_concepts''']      ) > 0 for res in result]

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

												if any(__A      ):
																	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 					__A       (     self:      Dict						,   __A:      torch.FloatTensor						,   __A:      torch.FloatTensor      )			-> Dict:
												_A									=       self.vision_model(__A      )[1]  # pooled_output
												_A									=       self.visual_projection(__A      )

												_A									=       cosine_distance(__A						,   self.special_care_embeds      )
												_A									=       cosine_distance(__A						,   self.concept_embeds      )

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

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

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

												_A									=       0.0  # black image

												return images, has_nsfw_concepts






from typing import Callable




def        lowerCAmelCase(	SCREAMING_SNAKE_CASE_       )->		List[Any]:



    """simple docstring"""






    def wrapper(SCREAMING_SNAKE_CASE_       ):
        UpperCamelCase_          =		function_with_docstring.__doc__
        return target_function

    return wrapper
