



'''simple docstring'''






from typing import Optional, Tuple

import jax
import jax.numpy as jnp
from flax import linen as nn
from flax.core.frozen_dict import FrozenDict
from transformers import CLIPConfig, FlaxPreTrainedModel
from transformers.models.clip.modeling_flax_clip import FlaxCLIPVisionModule
def  lowerCamelCase__			(		_A					,     _A					,     _A=1E-12							):
  a		:   List[Any]	  =	jnp.divide(emb_a.T					,     jnp.clip(jnp.linalg.norm(_A					,     axis=1							)					,     a_min=_A							)							).T
  a		:   int	  =	jnp.divide(emb_a.T					,     jnp.clip(jnp.linalg.norm(_A					,     axis=1							)					,     a_min=_A							)							).T
  return jnp.matmul(_A					,     norm_emb_a.T							)

class 				a__(   nn.Module      ):
    lowercase__					=       42
    lowercase__					=       jnp.floataa







    def      lowercase_			( self					:    str      ):
      a		:   Dict	  =	FlaxCLIPVisionModule(self.config.vision_config      )
      a		:   Dict	  =	nn.Dense(self.config.projection_dim		,     use_bias=__snake_case		,     dtype=self.dtype      )

      a		:   Optional[int]	  =	self.param('concept_embeds'		,     jax.nn.initializers.ones		,     (17, self.config.projection_dim)      )
      a		:   Any	  =	self.param(
          'special_care_embeds'		,     jax.nn.initializers.ones		,     (3, self.config.projection_dim)      )

      a		:   Optional[Any]	  =	self.param('concept_embeds_weights'		,     jax.nn.initializers.ones		,     (17,)      )
      a		:   Optional[Any]	  =	self.param('special_care_embeds_weights'		,     jax.nn.initializers.ones		,     (3,)      )







    def __call__( self					:    Optional[int]		,     __snake_case					:    List[str]      ):
      a		:   int	  =	self.vision_model(__snake_case      )[1]
      a		:   List[Any]	  =	self.visual_projection(__snake_case      )

      a		:   Tuple	  =	jax_cosine_distance(__snake_case		,     self.special_care_embeds      )
      a		:   Any	  =	jax_cosine_distance(__snake_case		,     self.concept_embeds      )

      # increase this value to create a stronger `nfsw` filter
      # at the cost of increasing the possibility of filtering benign image inputs
      a		:   Union[str, Any]	  =	0.0

      a		:   Dict	  =	special_cos_dist - self.special_care_embeds_weights[None, :] + adjustment
      a		:   Any	  =	jnp.round(__snake_case		,     3      )
      a		:   Optional[Any]	  =	jnp.any(special_scores > 0		,     axis=1		,     keepdims=__snake_case      )
      # Use a lower threshold if an image has any special care concept
      a		:   List[str]	  =	is_special_care * 0.01

      a		:   Any	  =	cos_dist - self.concept_embeds_weights[None, :] + special_adjustment
      a		:   Union[str, Any]	  =	jnp.round(__snake_case		,     3      )
      a		:   int	  =	jnp.any(concept_scores > 0		,     axis=1      )

      return has_nsfw_concepts

class 				a__(   lowerCamelCase__      ):
    lowercase__					=       CLIPConfig
    lowercase__					=       """clip_input"""
    lowercase__					=       FlaxStableDiffusionSafetyCheckerModule







    def __init__( self					:    int		,     __snake_case					:    CLIPConfig		,     __snake_case					:    Optional[Tuple] = None		,     __snake_case					:    int = 0		,     __snake_case					:    jnp.dtype = jnp.floataa		,     __snake_case					:    bool = True		,     **__snake_case					:    Dict		,     ):
      if input_shape is None:
        a		:   int	  =	(1, 2_24, 2_24, 3)
      a		:   Union[str, Any]	  =	self.module_class(config=__snake_case		,     dtype=__snake_case		,     **__snake_case      )
      super().__init__(__snake_case		,     __snake_case		,     input_shape=__snake_case		,     seed=__snake_case		,     dtype=__snake_case		,     _do_init=_do_init      )







    def      lowercase_			( self					:    List[str]		,     __snake_case					:    jax.random.KeyArray		,     __snake_case					:    Tuple		,     __snake_case					:    FrozenDict = None      ):
      # init input tensor
      a		:   List[Any]	  =	jax.random.normal(__snake_case		,     __snake_case      )

      a  ,      a		:   str	  =	jax.random.split(__snake_case      )
      a		:   List[str]	  =	{'params': params_rng, 'dropout': dropout_rng}

      a		:   int	  =	self.module.init(__snake_case		,     __snake_case      )['params']

      return random_params







    def __call__( self					:    Optional[Any]		,     __snake_case					:    Any		,     __snake_case					:    dict = None		,     ):
      a		:   str	  =	jnp.transpose(__snake_case		,     (0, 2, 3, 1)      )

      return self.module.apply(
          {'params': params or self.params}		,     jnp.array(__snake_case		,     dtype=jnp.floataa      )		,     rngs={}		,     )




'''simple docstring'''






from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase:   Optional[int]					=		logging.get_logger(__name__)

lowerCAmelCase:   int					=		{'ctrl': 'https://huggingface.co/ctrl/resolve/main/config.json'}

class 				a__(   lowerCamelCase__      ):
    lowercase__					=       """ctrl"""
    lowercase__					=       ["""past_key_values"""]
    lowercase__					=       {
        """max_position_embeddings""": """n_positions""",
        """hidden_size""": """n_embd""",
        """num_attention_heads""": """n_head""",
        """num_hidden_layers""": """n_layer""",
    }







    def __init__( self					:    Optional[int]		,     __snake_case					:    Union[str, Any]=24_65_34		,     __snake_case					:    Dict=2_56		,     __snake_case					:    Optional[int]=12_80		,     __snake_case					:    Optional[int]=81_92		,     __snake_case					:    Union[str, Any]=48		,     __snake_case					:    str=16		,     __snake_case					:    Any=0.1		,     __snake_case					:    List[Any]=0.1		,     __snake_case					:    str=1e-6		,     __snake_case					:    List[str]=0.02		,     __snake_case					:    int=True		,     **__snake_case					:    Any		,     ):
      a		:   int	  =	vocab_size
      a		:   Union[str, Any]	  =	n_positions
      a		:   Optional[int]	  =	n_embd
      a		:   Dict	  =	n_layer
      a		:   Union[str, Any]	  =	n_head
      a		:   Tuple	  =	dff
      a		:   Union[str, Any]	  =	resid_pdrop
      a		:   Tuple	  =	embd_pdrop
      a		:   int	  =	layer_norm_epsilon
      a		:   str	  =	initializer_range

      a		:   Any	  =	use_cache

      super().__init__(**__snake_case      )