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

from ...utils import logging


lowercase_ 				=			logging.get_logger(__name__)


def 							a__					(							snake_case       ,			snake_case							):





  """simple docstring"""
  __SCREAMING_SNAKE_CASE      :	Tuple					=		nn.functional.normalize(snake_case							)
  __SCREAMING_SNAKE_CASE      :	Tuple					=		nn.functional.normalize(snake_case							)
  return torch.mm(snake_case       ,			normalized_text_embeds.t()							)





class     __UpperCamelCase (							lowerCAmelCase__       ):






     """simple docstring"""







     lowerCAmelCase_							   =			CLIPConfig

     lowerCAmelCase_							   =			['''CLIPEncoderLayer''']



     def __init__(				self							:							List[Any]     ,						_A							:							CLIPConfig ):







       """simple docstring"""




       super().__init__(_A )

       __SCREAMING_SNAKE_CASE      :	List[Any]					=		CLIPVisionModel(config.vision_config )
       __SCREAMING_SNAKE_CASE      :	Any					=		nn.Linear(config.vision_config.hidden_size     ,						config.projection_dim     ,						bias=_A )

       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		nn.Parameter(torch.ones(17     ,						config.projection_dim )     ,						requires_grad=_A )
       __SCREAMING_SNAKE_CASE      :	List[Any]					=		nn.Parameter(torch.ones(3     ,						config.projection_dim )     ,						requires_grad=_A )

       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		nn.Parameter(torch.ones(17 )     ,						requires_grad=_A )
       __SCREAMING_SNAKE_CASE      :	List[str]					=		nn.Parameter(torch.ones(3 )     ,						requires_grad=_A )



     @torch.no_grad()
     def  UpperCAmelCase__							(				self							:							Union[str, Any]     ,						_A							:							Optional[int]     ,						_A							:							Any ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	str					=		self.vision_model(_A )[1]  # pooled_output
       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		self.visual_projection(_A )

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

       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		[]
       __SCREAMING_SNAKE_CASE      :	int					=		image_embeds.shape[0]
       for i in range(_A ):
         __SCREAMING_SNAKE_CASE      :	Dict					=		{'''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
         __SCREAMING_SNAKE_CASE      :	Optional[int]					=		0.0

         for concept_idx in range(len(special_cos_dist[0] ) ):
           __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		special_cos_dist[i][concept_idx]
           __SCREAMING_SNAKE_CASE      :	List[str]					=		self.special_care_embeds_weights[concept_idx].item()
           __SCREAMING_SNAKE_CASE      :	List[str]					=		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]} )
             __SCREAMING_SNAKE_CASE      :	Dict					=		0.01

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

         result.append(_A )

       __SCREAMING_SNAKE_CASE      :	Union[str, Any]					=		[len(res['''bad_concepts'''] ) > 0 for res in result]

       return images, has_nsfw_concepts




     @torch.no_grad()
     def  UpperCAmelCase__							(				self							:							str     ,						_A							:							torch.FloatTensor     ,						_A							:							torch.FloatTensor ):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE      :	Optional[int]					=		self.vision_model(_A )[1]  # pooled_output
       __SCREAMING_SNAKE_CASE      :	str					=		self.visual_projection(_A )

       __SCREAMING_SNAKE_CASE      :	List[Any]					=		cosine_distance(_A     ,						self.special_care_embeds )
       __SCREAMING_SNAKE_CASE      :	Optional[Any]					=		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
       __SCREAMING_SNAKE_CASE      :	int					=		0.0

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

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

       return images, has_nsfw_concepts


import warnings

from ...utils import logging
from .image_processing_yolos import YolosImageProcessor


__lowerCAmelCase					   =       logging.get_logger(__name__)





class     lowerCamelCase      (       __lowerCamelCase					):







	def __init__(     self      :List[Any]   ,     *lowercase      :List[str]   ,     **lowercase      :List[Any]			)		->      None:







				"""simple docstring"""






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