


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 							__lowercase     (				__lowerCAmelCase							:       Any      ,					__lowerCAmelCase							:       int      ,					__lowerCAmelCase							:       List[Any]=1E-1_2     ):
							a__    =  jnp.divide(emb_a.T      ,					jnp.clip(jnp.linalg.norm(__lowerCAmelCase      ,					axis=1     )      ,					a_min=__lowerCAmelCase     )     ).T
							a__    =  jnp.divide(emb_a.T      ,					jnp.clip(jnp.linalg.norm(__lowerCAmelCase      ,					axis=1     )      ,					a_min=__lowerCAmelCase     )     ).T
							return jnp.matmul(__lowerCAmelCase      ,					norm_emb_a.T     )







class  snake_case_     (nn.Module   ):
					UpperCAmelCase__      :					CLIPConfig
					UpperCAmelCase__      :					jnp.dtype					   =    jnp.floataa
					def 				lowerCamelCase__(   self     :str   )      ->					Optional[int]:
												a__    =  FlaxCLIPVisionModule(self.config.vision_config   )
												a__    =  nn.Dense(self.config.projection_dim    ,use_bias=__snake_case    ,dtype=self.dtype   )

												a__    =  self.param('concept_embeds'    ,jax.nn.initializers.ones    ,(17, self.config.projection_dim)   )
												a__    =  self.param(
												    'special_care_embeds'    ,jax.nn.initializers.ones    ,(3, self.config.projection_dim)   )

												a__    =  self.param('concept_embeds_weights'    ,jax.nn.initializers.ones    ,(17,)   )
												a__    =  self.param('special_care_embeds_weights'    ,jax.nn.initializers.ones    ,(3,)   )



					def __call__(   self     :Optional[Any]    ,__snake_case     :List[str]   )      ->					Dict:
												a__    =  self.vision_model(__snake_case   )[1]
												a__    =  self.visual_projection(__snake_case   )

												a__    =  jax_cosine_distance(__snake_case    ,self.special_care_embeds   )
												a__    =  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__    =  0.0

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

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

												return has_nsfw_concepts







class  snake_case_     (lowerCamelCase_   ):
					UpperCAmelCase__      :					Union[str, Any]					   =    CLIPConfig
					UpperCAmelCase__      :					Tuple					   =    '''clip_input'''
					UpperCAmelCase__      :					List[Any]					   =    FlaxStableDiffusionSafetyCheckerModule
					def __init__(   self     :List[Any]    ,__snake_case     :CLIPConfig    ,__snake_case     :Optional[Tuple] = None    ,__snake_case     :int = 0    ,__snake_case     :jnp.dtype = jnp.floataa    ,__snake_case     :bool = True    ,**__snake_case     :int    ,)      ->					List[str]:
												if input_shape is None:
																			a__    =  (1, 2_24, 2_24, 3)
												a__    =  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 				lowerCamelCase__(   self     :Union[str, Any]    ,__snake_case     :jax.random.KeyArray    ,__snake_case     :Tuple    ,__snake_case     :FrozenDict = None   )      ->					FrozenDict:
												# init input tensor
												a__    =  jax.random.normal(__snake_case    ,__snake_case   )

												a__   ,      a__    =  jax.random.split(__snake_case   )
												a__    =  {'params': params_rng, 'dropout': dropout_rng}

												a__    =  self.module.init(__snake_case    ,__snake_case   )['params']

												return random_params



					def __call__(   self     :List[Any]    ,__snake_case     :int    ,__snake_case     :dict = None    ,)      ->					List[Any]:
												a__    =  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={}    ,)




from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


snake_case							: Optional[Any]      =   {'''configuration_focalnet''': ['''FOCALNET_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''FocalNetConfig''']}


try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						snake_case							: Optional[int]      =   [
						    '''FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''FocalNetForImageClassification''',
						    '''FocalNetForMaskedImageModeling''',
						    '''FocalNetBackbone''',
						    '''FocalNetModel''',
						    '''FocalNetPreTrainedModel''',
						]

if TYPE_CHECKING:
						from .configuration_focalnet import FOCALNET_PRETRAINED_CONFIG_ARCHIVE_MAP, FocalNetConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_focalnet import (
												    FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST,
												    FocalNetBackbone,
												    FocalNetForImageClassification,
												    FocalNetForMaskedImageModeling,
												    FocalNetModel,
												    FocalNetPreTrainedModel,
												)

else:
						import sys

						snake_case							: Union[str, Any]      =   _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




