




'''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 		snake_case_   (UpperCamelCase	:  Optional[int]			,						UpperCamelCase	:  Union[str, Any]			,						UpperCamelCase	:  str=1e-12				):





							'''simple docstring'''


							_a     					=    jnp.divide(emb_a.T			,						jnp.clip(jnp.linalg.norm(UpperCamelCase			,						axis=1				)			,						a_min=UpperCamelCase				)				).T
							_a     					=    jnp.divide(emb_a.T			,						jnp.clip(jnp.linalg.norm(UpperCamelCase			,						axis=1				)			,						a_min=UpperCamelCase				)				).T
							return jnp.matmul(UpperCamelCase			,						norm_emb_a.T				)

class       A   (		nn.Module   ):
							lowercase_          =    42
							lowercase_          =    jnp.floataa







							def        __lowerCAmelCase      (  self	:  Any )      ->							Optional[int]:


														"""simple docstring"""


														_a     					=    FlaxCLIPVisionModule(self.config.vision_config )
														_a     					=    nn.Dense(self.config.projection_dim							,      use_bias=lowerCAmelCase_							,      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	:  Dict							,      lowerCAmelCase_	:  Any )      ->							Union[str, Any]:


														"""simple docstring"""


														_a     					=    self.vision_model(lowerCAmelCase_ )[1]
														_a     					=    self.visual_projection(lowerCAmelCase_ )

														_a     					=    jax_cosine_distance(lowerCAmelCase_							,      self.special_care_embeds )
														_a     					=    jax_cosine_distance(lowerCAmelCase_							,      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(lowerCAmelCase_							,      3 )
														_a     					=    jnp.any(special_scores > 0							,      axis=1							,      keepdims=lowerCAmelCase_ )
														# Use a lower threshold if an image has any special care concept
														_a     					=    is_special_care * 0.0_1

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

														return has_nsfw_concepts



class       A   (		_a   ):
							lowercase_          =    CLIPConfig
							lowercase_          =    'clip_input'
							lowercase_          =    FlaxStableDiffusionSafetyCheckerModule







							def __init__(  self	:  Any							,      lowerCAmelCase_	:  CLIPConfig							,      lowerCAmelCase_	:  Optional[Tuple] = None							,      lowerCAmelCase_	:  int = 0							,      lowerCAmelCase_	:  jnp.dtype = jnp.floataa							,      lowerCAmelCase_	:  bool = True							,      **lowerCAmelCase_	:  List[str]							,      )      ->							List[Any]:


														"""simple docstring"""


														if input_shape is None:
																					_a     					=    (1, 2_24, 2_24, 3)
														_a     					=    self.module_class(config=lowerCAmelCase_							,      dtype=lowerCAmelCase_							,      **lowerCAmelCase_ )
														super().__init__(lowerCAmelCase_							,      lowerCAmelCase_							,      input_shape=lowerCAmelCase_							,      seed=lowerCAmelCase_							,      dtype=lowerCAmelCase_							,      _do_init=_do_init )







							def        __lowerCAmelCase      (  self	:  Optional[Any]							,      lowerCAmelCase_	:  jax.random.KeyArray							,      lowerCAmelCase_	:  Tuple							,      lowerCAmelCase_	:  FrozenDict = None )      ->							FrozenDict:


														"""simple docstring"""


														_a     					=    jax.random.normal(lowerCAmelCase_							,      lowerCAmelCase_ )

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

														_a     					=    self.module.init(lowerCAmelCase_							,      lowerCAmelCase_ )['''params''']

														return random_params







							def __call__(  self	:  List[Any]							,      lowerCAmelCase_	:  Any							,      lowerCAmelCase_	:  dict = None							,      )      ->							List[Any]:


														"""simple docstring"""


														_a     					=    jnp.transpose(lowerCAmelCase_							,      (0, 2, 3, 1) )

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







'''simple docstring'''


from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available

@dataclass
class       A   (		_a   ):
							lowercase_          =    42
							lowercase_          =    42


if is_transformers_available() and is_torch_available():
				from .pipeline_semantic_stable_diffusion import SemanticStableDiffusionPipeline

