






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

from ...utils import logging


snake_case__   :						Tuple													=   logging.get_logger(__name__)






def      _snake_case     (__lowercase     ,   __lowercase):
   UpperCamelCase_						=  nn.functional.normalize(__lowercase)
   UpperCamelCase_						=  nn.functional.normalize(__lowercase)
   return torch.mm(__lowercase     ,   normalized_text_embeds.t())


class     _a							(	UpperCAmelCase__     ):






  """simple docstring"""





  A_						       = CLIPConfig

  A_						       = ["""CLIPEncoderLayer"""]




  def __init__(  self		,		_UpperCAmelCase			)      ->			Dict:
     super().__init__(_UpperCAmelCase			)

     UpperCamelCase_						=  CLIPVisionModel(config.vision_config			)
     UpperCamelCase_						=  nn.Linear(config.vision_config.hidden_size		,		config.projection_dim		,		bias=_UpperCAmelCase			)

     UpperCamelCase_						=  nn.Parameter(torch.ones(17		,		config.projection_dim			)		,		requires_grad=_UpperCAmelCase			)
     UpperCamelCase_						=  nn.Parameter(torch.ones(3		,		config.projection_dim			)		,		requires_grad=_UpperCAmelCase			)

     UpperCamelCase_						=  nn.Parameter(torch.ones(17			)		,		requires_grad=_UpperCAmelCase			)
     UpperCamelCase_						=  nn.Parameter(torch.ones(3			)		,		requires_grad=_UpperCAmelCase			)




  @torch.no_grad()
  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Optional[Any]:
     UpperCamelCase_						=  self.vision_model(_UpperCAmelCase			)[1]  # pooled_output
     UpperCamelCase_						=  self.visual_projection(_UpperCAmelCase			)

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

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

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

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

        result.append(_UpperCAmelCase			)

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

     return images, has_nsfw_concepts




  @torch.no_grad()
  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			List[str]:
     UpperCamelCase_						=  self.vision_model(_UpperCAmelCase			)[1]  # pooled_output
     UpperCamelCase_						=  self.visual_projection(_UpperCAmelCase			)

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

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

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

     return images, has_nsfw_concepts







'''simple docstring'''
import warnings

from ...utils import logging
from .image_processing_glpn import GLPNImageProcessor


lowercase__						       =      logging.get_logger(__name__)






class 	snake_case__       (      __SCREAMING_SNAKE_CASE					):







		"""simple docstring"""

		def __init__(      self				:			Optional[Any]  ,	*UpperCamelCase__				:			Optional[Any]  ,	**UpperCamelCase__				:			str      )						->			None:






				"""simple docstring"""







				warnings.warn(
				    '''The class GLPNFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'''
				    ''' use GLPNImageProcessor instead.'''  ,	UpperCamelCase__  ,	)
				super().__init__(*UpperCamelCase__  ,	**UpperCamelCase__      )


