




'''simple docstring'''







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

from ...utils import logging


_lowerCamelCase							:						int								=  logging.get_logger(__name__)






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		_snake_case	       =       nn.functional.normalize(lowercase_  )
		_snake_case	       =       nn.functional.normalize(lowercase_  )
		return torch.mm(lowercase_						,							normalized_text_embeds.t()  )





class      lowerCamelCase_							(       UpperCAmelCase_							):




					'''simple docstring'''






					lowercase__    = CLIPConfig

					lowercase__    = ["""CLIPEncoderLayer"""]






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

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

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

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






					@torch.no_grad()
					def 				__SCREAMING_SNAKE_CASE	(    self,  __UpperCamelCase,  __UpperCamelCase ):
							_snake_case	       =       self.vision_model(__UpperCamelCase )[1]  # pooled_output
							_snake_case	       =       self.visual_projection(__UpperCamelCase )

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

							_snake_case	       =       []
							_snake_case	       =       image_embeds.shape[0]
							for i in range(__UpperCamelCase ):
									_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(__UpperCamelCase )

									result.append(__UpperCamelCase )

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

							for idx, has_nsfw_concept in enumerate(__UpperCamelCase ):
									if has_nsfw_concept:
											if torch.is_tensor(__UpperCamelCase ) 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(__UpperCamelCase ):
									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 				__SCREAMING_SNAKE_CASE	(    self,  __UpperCamelCase,  __UpperCamelCase ):
							_snake_case	       =       self.vision_model(__UpperCamelCase )[1]  # pooled_output
							_snake_case	       =       self.visual_projection(__UpperCamelCase )

							_snake_case	       =       cosine_distance(__UpperCamelCase,  self.special_care_embeds )
							_snake_case	       =       cosine_distance(__UpperCamelCase,  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							:						Optional[Any]								=  {'configuration_bit': ['BIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'BitConfig', 'BitOnnxConfig']}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowerCamelCase							:						Dict								=  [
						    'BIT_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'BitForImageClassification',
						    'BitModel',
						    'BitPreTrainedModel',
						    'BitBackbone',
						]


try:
						if not is_vision_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowerCamelCase							:						Union[str, Any]								=  ['BitImageProcessor']


if TYPE_CHECKING:
						from .configuration_bit import BIT_PRETRAINED_CONFIG_ARCHIVE_MAP, BitConfig, BitOnnxConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_bit import (
												    BIT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    BitBackbone,
												    BitForImageClassification,
												    BitModel,
												    BitPreTrainedModel,
												)

						try:
												if not is_vision_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .image_processing_bit import BitImageProcessor

else:
						import sys

						_lowerCamelCase							:						Optional[Any]								=  _LazyModule(__name__, globals()['__file__'], _import_structure)





