


'''simple docstring'''






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

from ...utils import logging


a_					:    str          =    logging.get_logger(__name__)






def 	_A				(lowerCAmelCase__  :str				,						lowerCAmelCase__  :Dict		)   ->  int:




     '''simple docstring'''



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






class  a     (     _SCREAMING_SNAKE_CASE       ):
 _lowerCAmelCase 					=	CLIPConfig

 _lowerCAmelCase 					=	["""CLIPEncoderLayer"""]
 def __init__( self      ,				__magic_name__						)					->							Union[str, Any]:
      super().__init__(__magic_name__						)

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

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

      _a			      =							nn.Parameter(torch.ones(17						)      ,				requires_grad=__magic_name__						)
      _a			      =							nn.Parameter(torch.ones(3						)      ,				requires_grad=__magic_name__						)
 @torch.no_grad()
 def 							__UpperCAmelCase		( self      ,				__magic_name__      ,				__magic_name__						)					->							int:
      _a			      =							self.vision_model(__magic_name__						)[1]  # pooled_output
      _a			      =							self.visual_projection(__magic_name__						)

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

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

           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(__magic_name__						)

           result.append(__magic_name__						)

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

      return images, has_nsfw_concepts




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

      _a			      =							cosine_distance(__magic_name__      ,				self.special_care_embeds						)
      _a			      =							cosine_distance(__magic_name__      ,				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.0_1
      _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'''






import pytest

from datasets.splits import SplitDict, SplitInfo
from datasets.utils.py_utils import asdict






@pytest.mark.parametrize(
    'split_dict'				,						[
        SplitDict(),
        SplitDict({'train': SplitInfo(name='train'				,						num_bytes=13_37				,						num_examples=42				,						dataset_name='my_dataset'		)}		),
        SplitDict({'train': SplitInfo(name='train'				,						num_bytes=13_37				,						num_examples=42		)}		),
        SplitDict({'train': SplitInfo()}		),
    ]				,						)
def 	_A				(lowerCAmelCase__  :SplitDict		)   ->  Any:




     '''simple docstring'''



     _a			      =							split_dict._to_yaml_list()
     assert len(lowerCAmelCase__		) == len(lowerCAmelCase__		)
     _a			      =							SplitDict._from_yaml_list(lowerCAmelCase__		)
     for split_name, split_info in split_dict.items():
          # dataset_name field is deprecated, and is therefore not part of the YAML dump
          _a			      =							None
          # the split name of split_dict takes over the name of the split info object
          _a			      =							split_name
     assert split_dict == reloaded






@pytest.mark.parametrize(
    'split_info'				,						[SplitInfo(), SplitInfo(dataset_name=lowerCAmelCase__		), SplitInfo(dataset_name='my_dataset'		)]		)
def 	_A				(lowerCAmelCase__  :Optional[Any]		)   ->  List[str]:




     '''simple docstring'''



     _a			      =							asdict(SplitDict({'train': split_info}		)		)
     assert "dataset_name" in split_dict_asdict["train"]
     assert split_dict_asdict["train"]["dataset_name"] == split_info.dataset_name

