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

from ...utils import logging


__lowerCAmelCase  							=					logging.get_logger(__name__)






def       __SCREAMING_SNAKE_CASE   (						_SCREAMING_SNAKE_CASE							,      _SCREAMING_SNAKE_CASE   ):
							_snake_case     =						nn.functional.normalize(snake_case__   )
							_snake_case     =						nn.functional.normalize(snake_case__   )
							return torch.mm(snake_case__							,      normalized_text_embeds.t()   )


class     _lowerCAmelCase					(					a__   ):







							'''simple docstring'''

							lowerCAmelCase_      		=		CLIPConfig

							lowerCAmelCase_      		=		["CLIPEncoderLayer"]

							def __init__(self						,						UpperCAmelCase						)  ->     List[str]:
														super().__init__(SCREAMING_SNAKE_CASE_						)

														_snake_case     =						CLIPVisionModel(config.vision_config						)
														_snake_case     =						nn.Linear(config.vision_config.hidden_size						,						config.projection_dim						,						bias=SCREAMING_SNAKE_CASE_						)

														_snake_case     =						nn.Parameter(torch.ones(17						,						config.projection_dim						)						,						requires_grad=SCREAMING_SNAKE_CASE_						)
														_snake_case     =						nn.Parameter(torch.ones(3						,						config.projection_dim						)						,						requires_grad=SCREAMING_SNAKE_CASE_						)

														_snake_case     =						nn.Parameter(torch.ones(17						)						,						requires_grad=SCREAMING_SNAKE_CASE_						)
														_snake_case     =						nn.Parameter(torch.ones(3						)						,						requires_grad=SCREAMING_SNAKE_CASE_						)

							@torch.no_grad()
							def  lowercase							(self						,						UpperCAmelCase						,						UpperCAmelCase						)  ->     Union[str, Any]:
														_snake_case     =						self.vision_model(SCREAMING_SNAKE_CASE_						)[1]  # pooled_output
														_snake_case     =						self.visual_projection(SCREAMING_SNAKE_CASE_						)

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

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

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

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

																					result.append(SCREAMING_SNAKE_CASE_						)

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

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

														if any(SCREAMING_SNAKE_CASE_						):
																					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  lowercase							(self						,						UpperCAmelCase						,						UpperCAmelCase						)  ->     Optional[int]:
														_snake_case     =						self.vision_model(SCREAMING_SNAKE_CASE_						)[1]  # pooled_output
														_snake_case     =						self.visual_projection(SCREAMING_SNAKE_CASE_						)

														_snake_case     =						cosine_distance(SCREAMING_SNAKE_CASE_						,						self.special_care_embeds						)
														_snake_case     =						cosine_distance(SCREAMING_SNAKE_CASE_						,						self.concept_embeds						)

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

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

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

														_snake_case     =						0.0  # black image

														return images, has_nsfw_concepts

'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__lowerCAmelCase  							= {
    'configuration_deta': ['DETA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DetaConfig'],
}

try:
				if not is_vision_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase  							= ['DetaImageProcessor']

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase  							= [
				    'DETA_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'DetaForObjectDetection',
				    'DetaModel',
				    'DetaPreTrainedModel',
				]


if TYPE_CHECKING:
				from .configuration_deta import DETA_PRETRAINED_CONFIG_ARCHIVE_MAP, DetaConfig

				try:
								if not is_vision_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .image_processing_deta import DetaImageProcessor

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_deta import (
								    DETA_PRETRAINED_MODEL_ARCHIVE_LIST,
								    DetaForObjectDetection,
								    DetaModel,
								    DetaPreTrainedModel,
								)

else:
				import sys

				__lowerCAmelCase  							= _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)