



'''simple docstring'''


from typing import List

import numpy as np







def 				__lowerCamelCase				(   A__    )       ->	int:






   """simple docstring"""
   UpperCamelCase					=  {key: len(A__    ) for key, value in gen_kwargs.items() if isinstance(A__    ,						A__    )}
   if len(set(lists_lengths.values()    )    ) > 1:
      raise RuntimeError(
          (
              'Sharding is ambiguous for this dataset: '
              + 'we found several data sources lists of different lengths, and we don\'t know over which list we should parallelize:\n'
              + '\n'.join(F"""\t- key {key} has length {length}""" for key, length in lists_lengths.items()    )
              + '\nTo fix this, check the \'gen_kwargs\' and make sure to use lists only for data sources, '
              + 'and use tuples otherwise. In the end there should only be one single list, or several lists with the same length.'
          )    )
   UpperCamelCase					=  max(lists_lengths.values()    ,						default=0    )
   return max(1    ,						A__    )







def 				__lowerCamelCase				(   A__    ,						A__    )       ->	List[range]:






   """simple docstring"""
   UpperCamelCase					=  []
   for group_idx in range(A__    ):
      UpperCamelCase					=  num_shards // max_num_jobs + (group_idx < (num_shards % max_num_jobs))
      if num_shards_to_add == 0:
         break
      UpperCamelCase					=  shards_indices_per_group[-1].stop if shards_indices_per_group else 0
      UpperCamelCase					=  range(A__    ,						start + num_shards_to_add    )
      shards_indices_per_group.append(A__    )
   return shards_indices_per_group







def 				__lowerCamelCase				(   A__    ,						A__    )       ->	List[dict]:






   """simple docstring"""
   UpperCamelCase					=  _number_of_shards_in_gen_kwargs(A__    )
   if num_shards == 1:
      return [dict(A__    )]
   else:
      UpperCamelCase					=  _distribute_shards(num_shards=A__    ,						max_num_jobs=A__    )
      return [
          {
              key: [value[shard_idx] for shard_idx in shard_indices_per_group[group_idx]]
              if isinstance(A__    ,						A__    )
              else value
              for key, value in gen_kwargs.items()
          }
          for group_idx in range(len(A__    )    )
      ]







def 				__lowerCamelCase				(   A__    )       ->	dict:






   """simple docstring"""
   return {
       key: [value for gen_kwargs in gen_kwargs_list for value in gen_kwargs[key]]
       if isinstance(gen_kwargs_list[0][key]    ,						A__    )
       else gen_kwargs_list[0][key]
       for key in gen_kwargs_list[0]
   }







def 				__lowerCamelCase				(   A__    ,						A__    )       ->	dict:






   """simple docstring"""
   UpperCamelCase					=  {len(A__    ) for value in gen_kwargs.values() if isinstance(A__    ,						A__    )}
   UpperCamelCase					=  {}
   for size in list_sizes:
      UpperCamelCase					=  list(range(A__    )    )
      rng.shuffle(indices_per_size[size]    )
   # Now let's copy the gen_kwargs and shuffle the lists based on their sizes
   UpperCamelCase					=  dict(A__    )
   for key, value in shuffled_kwargs.items():
      if isinstance(A__    ,						A__    ):
         UpperCamelCase					=  [value[i] for i in indices_per_size[len(A__    )]]
   return shuffled_kwargs






'''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-1_2    )       ->	Dict:






   """simple docstring"""
   UpperCamelCase					=  jnp.divide(emb_a.T    ,						jnp.clip(jnp.linalg.norm(A__    ,						axis=1    )    ,						a_min=A__    )    ).T
   UpperCamelCase					=  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  SCREAMING_SNAKE_CASE (  nn.Module		):






    """simple docstring"""





    _SCREAMING_SNAKE_CASE	  =  42
    _SCREAMING_SNAKE_CASE	  =  jnp.floataa






    def  A       (  self      :					List[Any] ):


       """simple docstring"""







       UpperCamelCase					=  FlaxCLIPVisionModule(self.config.vision_config )
       UpperCamelCase					=  nn.Dense(self.config.projection_dim  ,						use_bias=UpperCamelCase__  ,						dtype=self.dtype )

       UpperCamelCase					=  self.param('concept_embeds'  ,						jax.nn.initializers.ones  ,						(1_7, self.config.projection_dim) )
       UpperCamelCase					=  self.param(
           'special_care_embeds'  ,						jax.nn.initializers.ones  ,						(3, self.config.projection_dim) )

       UpperCamelCase					=  self.param('concept_embeds_weights'  ,						jax.nn.initializers.ones  ,						(1_7,) )
       UpperCamelCase					=  self.param('special_care_embeds_weights'  ,						jax.nn.initializers.ones  ,						(3,) )






    def __call__(  self      :					str  ,						UpperCamelCase__      :					List[str] ):


       """simple docstring"""







       UpperCamelCase					=  self.vision_model(UpperCamelCase__ )[1]
       UpperCamelCase					=  self.visual_projection(UpperCamelCase__ )

       UpperCamelCase					=  jax_cosine_distance(UpperCamelCase__  ,						self.special_care_embeds )
       UpperCamelCase					=  jax_cosine_distance(UpperCamelCase__  ,						self.concept_embeds )

       # increase this value to create a stronger `nfsw` filter
       # at the cost of increasing the possibility of filtering benign image inputs
       UpperCamelCase					=  0.0

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

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

       return has_nsfw_concepts

class  SCREAMING_SNAKE_CASE (  _a		):






    """simple docstring"""





    _SCREAMING_SNAKE_CASE	  =  CLIPConfig
    _SCREAMING_SNAKE_CASE	  =  """clip_input"""
    _SCREAMING_SNAKE_CASE	  =  FlaxStableDiffusionSafetyCheckerModule






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


       """simple docstring"""







       if input_shape is None:
          UpperCamelCase					=  (1, 2_2_4, 2_2_4, 3)
       UpperCamelCase					=  self.module_class(config=UpperCamelCase__  ,						dtype=UpperCamelCase__  ,						**UpperCamelCase__ )
       super().__init__(UpperCamelCase__  ,						UpperCamelCase__  ,						input_shape=UpperCamelCase__  ,						seed=UpperCamelCase__  ,						dtype=UpperCamelCase__  ,						_do_init=_do_init )






    def  A       (  self      :					int  ,						UpperCamelCase__      :					jax.random.KeyArray  ,						UpperCamelCase__      :					Tuple  ,						UpperCamelCase__      :					FrozenDict = None ):


       """simple docstring"""







       UpperCamelCase					=  jax.random.normal(UpperCamelCase__  ,						UpperCamelCase__ )

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

       UpperCamelCase					=  self.module.init(UpperCamelCase__  ,						UpperCamelCase__ )['params']

       return random_params






    def __call__(  self      :					List[Any]  ,						UpperCamelCase__      :					Dict  ,						UpperCamelCase__      :					dict = None  ,						):


       """simple docstring"""







       UpperCamelCase					=  jnp.transpose(UpperCamelCase__  ,						(0, 2, 3, 1) )

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

