


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							:    Tuple ,   __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       :Dict				) ->   Union[str, Any]:
												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]				) ->   Union[str, Any]:
												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__ :   Union[str, Any]   				=      '''clip_input'''
					UpperCAmelCase__ :   Tuple   				=      FlaxStableDiffusionSafetyCheckerModule
					def __init__(				self       :Union[str, 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       :Tuple      ,) ->   Any:
												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       :int      ,__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       :Optional[Any]      ,__snake_case       :Optional[int]      ,__snake_case       :dict = None      ,) ->   Tuple:
												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

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


snake_case							:	Optional[int]					      =				{
    '''configuration_clipseg''': [
        '''CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''CLIPSegConfig''',
        '''CLIPSegTextConfig''',
        '''CLIPSegVisionConfig''',
    ],
    '''processing_clipseg''': ['''CLIPSegProcessor'''],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						snake_case							:	List[str]					      =				[
						    '''CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''CLIPSegModel''',
						    '''CLIPSegPreTrainedModel''',
						    '''CLIPSegTextModel''',
						    '''CLIPSegVisionModel''',
						    '''CLIPSegForImageSegmentation''',
						]

if TYPE_CHECKING:
						from .configuration_clipseg import (
						    CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    CLIPSegConfig,
						    CLIPSegTextConfig,
						    CLIPSegVisionConfig,
						)
						from .processing_clipseg import CLIPSegProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_clipseg import (
												    CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST,
												    CLIPSegForImageSegmentation,
												    CLIPSegModel,
												    CLIPSegPreTrainedModel,
												    CLIPSegTextModel,
												    CLIPSegVisionModel,
												)

else:
						import sys

						snake_case							:	Optional[int]					      =				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




