


"""simple docstring"""






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

from ...utils import logging


__snake_case		=       logging.get_logger(__name__)
def       A_   (   _lowerCAmelCase     :					str,     _lowerCAmelCase     :					Optional[int]       ):






     """simple docstring"""

     _a    	=				nn.functional.normalize(_lowerCAmelCase       )
     _a    	=				nn.functional.normalize(_lowerCAmelCase       )
     return torch.mm(_lowerCAmelCase,     normalized_text_embeds.t()       )


class     __lowerCamelCase  (					a__				):

     '''simple docstring'''
     A_       :	Union[str, Any]    =		CLIPConfig

     A_       :	Optional[Any]    =		['CLIPEncoderLayer']


     def __init__(      self    ,				__UpperCAmelCase							)       ->							List[Any]:
          super().__init__(__UpperCAmelCase							)

          _a    	=				CLIPVisionModel(config.vision_config							)
          _a    	=				nn.Linear(config.vision_config.hidden_size    ,				config.projection_dim    ,				bias=__UpperCAmelCase							)

          _a    	=				nn.Parameter(torch.ones(17    ,				config.projection_dim							)    ,				requires_grad=__UpperCAmelCase							)
          _a    	=				nn.Parameter(torch.ones(3    ,				config.projection_dim							)    ,				requires_grad=__UpperCAmelCase							)

          _a    	=				nn.Parameter(torch.ones(17							)    ,				requires_grad=__UpperCAmelCase							)
          _a    	=				nn.Parameter(torch.ones(3							)    ,				requires_grad=__UpperCAmelCase							)


     @torch.no_grad()
     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase							)       ->							Dict:
          _a    	=				self.vision_model(__UpperCAmelCase							)[1]  # pooled_output
          _a    	=				self.visual_projection(__UpperCAmelCase							)

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

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

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

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

               result.append(__UpperCAmelCase							)

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

          return images, has_nsfw_concepts





     @torch.no_grad()
     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase							)       ->							Dict:
          _a    	=				self.vision_model(__UpperCAmelCase							)[1]  # pooled_output
          _a    	=				self.visual_projection(__UpperCAmelCase							)

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

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

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

          return images, has_nsfw_concepts



"""simple docstring"""






from .glue import glue_convert_examples_to_features, glue_output_modes, glue_processors, glue_tasks_num_labels
from .squad import SquadExample, SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features
from .utils import DataProcessor, InputExample, InputFeatures, SingleSentenceClassificationProcessor
from .xnli import xnli_output_modes, xnli_processors, xnli_tasks_num_labels