'''simple docstring'''

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

from ...utils import logging


lowerCAmelCase_ : Any						  =      logging.get_logger(__name__)


def __a (	__lowerCamelCase			:						Optional[int] ,		__lowerCamelCase			:						List[str]				)	->							Union[str, Any]:
      '''simple docstring'''


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






class 							lowercase						(						__lowerCamelCase ):
   lowerCamelCase_    					=CLIPConfig

   lowerCamelCase_    					=['CLIPEncoderLayer']


   def __init__(   self				:	int   ,		__lowerCAmelCase				:	CLIPConfig)      ->					Tuple:
         super().__init__(__lowerCAmelCase)

         lowercase_     =      CLIPVisionModel(config.vision_config)
         lowercase_     =      nn.Linear(config.vision_config.hidden_size   ,		config.projection_dim   ,		bias=__lowerCAmelCase)

         lowercase_     =      nn.Parameter(torch.ones(17   ,		config.projection_dim)   ,		requires_grad=__lowerCAmelCase)
         lowercase_     =      nn.Parameter(torch.ones(3   ,		config.projection_dim)   ,		requires_grad=__lowerCAmelCase)

         lowercase_     =      nn.Parameter(torch.ones(17)   ,		requires_grad=__lowerCAmelCase)
         lowercase_     =      nn.Parameter(torch.ones(3)   ,		requires_grad=__lowerCAmelCase)


   @torch.no_grad()
   def __UpperCAmelCase       (   self				:	str   ,		__lowerCAmelCase				:	Tuple   ,		__lowerCAmelCase				:	List[str])      ->					List[str]:
         lowercase_     =      self.vision_model(__lowerCAmelCase)[1]  # pooled_output
         lowercase_     =      self.visual_projection(__lowerCAmelCase)

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

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

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

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

               result.append(__lowerCAmelCase)

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

         return images, has_nsfw_concepts


   @torch.no_grad()
   def __UpperCAmelCase       (   self				:	str   ,		__lowerCAmelCase				:	torch.FloatTensor   ,		__lowerCAmelCase				:	torch.FloatTensor)      ->					Optional[int]:
         lowercase_     =      self.vision_model(__lowerCAmelCase)[1]  # pooled_output
         lowercase_     =      self.visual_projection(__lowerCAmelCase)

         lowercase_     =      cosine_distance(__lowerCAmelCase   ,		self.special_care_embeds)
         lowercase_     =      cosine_distance(__lowerCAmelCase   ,		self.concept_embeds)

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

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

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

         return images, has_nsfw_concepts







'''simple docstring'''

def __a (	__lowerCamelCase			:						list[int] ,		__lowerCamelCase			:						int				)	->							bool:
      '''simple docstring'''


      lowercase_     =      len(__lowerCamelCase				)
      lowercase_     =      [[False] * (required_sum + 1) for _ in range(arr_len + 1				)]

      # for each arr value, a sum of zero(0) can be formed by not taking any element
      # hence True/1
      for i in range(arr_len + 1				):
            lowercase_     =      True

      # sum is not zero and set is empty then false
      for i in range(1 ,		required_sum + 1				):
            lowercase_     =      False

      for i in range(1 ,		arr_len + 1				):
            for j in range(1 ,		required_sum + 1				):
                  if arr[i - 1] > j:
                        lowercase_     =      subset[i - 1][j]
                  if arr[i - 1] <= j:
                        lowercase_     =      subset[i - 1][j] or subset[i - 1][j - arr[i - 1]]

      return subset[arr_len][required_sum]


if __name__ == "__main__":
       import doctest

       doctest.testmod()






