






"""simple docstring"""



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

from ...utils import logging


_lowerCAmelCase  :  int   =			logging.get_logger(__name__)


def   SCREAMING_SNAKE_CASE__					(     snake_case					:   Tuple ,				snake_case					:   List[str]							)->		Optional[Any]:






     '''simple docstring'''



     UpperCAmelCase__	:						str       =       nn.functional.normalize(snake_case							)
     UpperCAmelCase__	:						Optional[Any]       =       nn.functional.normalize(snake_case							)
     return torch.mm(snake_case ,				normalized_text_embeds.t()							)




class  lowerCAmelCase__ (						__magic_name__      ):
      SCREAMING_SNAKE_CASE_         =CLIPConfig

      SCREAMING_SNAKE_CASE_         =['''CLIPEncoderLayer''']
      def __init__(		self			:  str       , snake_case__			:  CLIPConfig       ):


           '''simple docstring'''
           super().__init__(snake_case__       )

           UpperCAmelCase__	:						Optional[int]       =       CLIPVisionModel(config.vision_config       )
           UpperCAmelCase__	:						Dict       =       nn.Linear(config.vision_config.hidden_size       , config.projection_dim       , bias=snake_case__       )

           UpperCAmelCase__	:						Tuple       =       nn.Parameter(torch.ones(1_7       , config.projection_dim       )       , requires_grad=snake_case__       )
           UpperCAmelCase__	:						Tuple       =       nn.Parameter(torch.ones(3       , config.projection_dim       )       , requires_grad=snake_case__       )

           UpperCAmelCase__	:						Union[str, Any]       =       nn.Parameter(torch.ones(1_7       )       , requires_grad=snake_case__       )
           UpperCAmelCase__	:						Dict       =       nn.Parameter(torch.ones(3       )       , requires_grad=snake_case__       )
      @torch.no_grad()
      def 			__a       (		self			:  Optional[Any]       , snake_case__			:  Optional[Any]       , snake_case__			:  Dict       ):


           '''simple docstring'''
           UpperCAmelCase__	:						Tuple       =       self.vision_model(snake_case__       )[1]  # pooled_output
           UpperCAmelCase__	:						List[str]       =       self.visual_projection(snake_case__       )

           # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
           UpperCAmelCase__	:						Any       =       cosine_distance(snake_case__       , self.special_care_embeds       ).cpu().float().numpy()
           UpperCAmelCase__	:						Union[str, Any]       =       cosine_distance(snake_case__       , self.concept_embeds       ).cpu().float().numpy()

           UpperCAmelCase__	:						Tuple       =       []
           UpperCAmelCase__	:						Optional[Any]       =       image_embeds.shape[0]
           for i in range(snake_case__       ):
                UpperCAmelCase__	:						List[str]       =       {"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__	:						Union[str, Any]       =       0.0

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

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

                result.append(snake_case__       )

           UpperCAmelCase__	:						List[str]       =       [len(res["bad_concepts"]       ) > 0 for res in result]

           for idx, has_nsfw_concept in enumerate(snake_case__       ):
                if has_nsfw_concept:
                     if torch.is_tensor(snake_case__       ) or torch.is_tensor(images[0]       ):
                          UpperCAmelCase__	:						Any       =       torch.zeros_like(images[idx]       )  # black image
                     else:
                          UpperCAmelCase__	:						Tuple       =       np.zeros(images[idx].shape       )  # black image

           if any(snake_case__       ):
                logger.warning(
                    "Potential NSFW content was detected in one or more images. A black image will be returned instead."
                    " Try again with a different prompt and/or seed."       )

           return images, has_nsfw_concepts




      @torch.no_grad()
      def 			__a       (		self			:  Dict       , snake_case__			:  torch.FloatTensor       , snake_case__			:  torch.FloatTensor       ):


           '''simple docstring'''
           UpperCAmelCase__	:						Optional[int]       =       self.vision_model(snake_case__       )[1]  # pooled_output
           UpperCAmelCase__	:						int       =       self.visual_projection(snake_case__       )

           UpperCAmelCase__	:						Optional[Any]       =       cosine_distance(snake_case__       , self.special_care_embeds       )
           UpperCAmelCase__	:						int       =       cosine_distance(snake_case__       , self.concept_embeds       )

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

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

           UpperCAmelCase__	:						Union[str, Any]       =       (cos_dist - self.concept_embeds_weights) + special_adjustment
           # concept_scores = concept_scores.round(decimals=3)
           UpperCAmelCase__	:						List[str]       =       torch.any(concept_scores > 0       , dim=1       )

           UpperCAmelCase__	:						Optional[int]       =       0.0  # black image

           return images, has_nsfw_concepts










"""simple docstring"""



def   SCREAMING_SNAKE_CASE__					(     snake_case					:   int							)->		list:






     '''simple docstring'''



     UpperCAmelCase__	:						List[str]       =       [True for i in range(n + 1							)]
     UpperCAmelCase__	:						List[str]       =       [i - 1 for i in range(n + 1							)]
     UpperCAmelCase__	:						int       =       []
     for i in range(2 ,				n + 1							):
          if is_prime[i]:
               primes.append(snake_case							)
          for j in range(0 ,				len(snake_case							)							):
               if i * primes[j] >= n:
                    break
               UpperCAmelCase__	:						Optional[Any]       =       False

               if i % primes[j] == 0:
                    UpperCAmelCase__	:						str       =       totients[i] * primes[j]
                    break

               UpperCAmelCase__	:						Union[str, Any]       =       totients[i] * (primes[j] - 1)

     return totients


if __name__ == "__main__":
 import doctest

 doctest.testmod()


