






import os
import sys
import tempfile

import torch

from .state import AcceleratorState
from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment






def 							lowerCamelCase__ (       __lowerCamelCase     :	Optional[Any]    ,						__lowerCamelCase     :	str=()    ,						__lowerCamelCase     :	List[str]=None    ,						__lowerCamelCase     :	List[str]="no"    ,						__lowerCamelCase     :	Dict="29500"						):
  __UpperCAmelCase				:      int	 =    False
  __UpperCAmelCase				:      List[Any]	 =    False
  if any(key.startswith("""KAGGLE"""						) for key in os.environ.keys()						):
    __UpperCAmelCase				:      Any	 =    True
  elif "IPython" in sys.modules:
    __UpperCAmelCase				:      Optional[Any]	 =    """google.colab""" in str(sys.modules["""IPython"""].get_ipython()						)

  try:
    __UpperCAmelCase				:      Dict	 =    PrecisionType(mixed_precision.lower()						)
  except ValueError:
    raise ValueError(
        f"""Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}."""						)

  if (in_colab or in_kaggle) and (os.environ.get("""TPU_NAME"""    ,						__lowerCamelCase						) is not None):
    # TPU launch
    import torch_xla.distributed.xla_multiprocessing as xmp

    if len(AcceleratorState._shared_state						) > 0:
      raise ValueError(
          """To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside """
          """your training function. Restart your notebook and make sure no cells initializes an """
          """`Accelerator`."""						)
    if num_processes is None:
      __UpperCAmelCase				:      int	 =    8

    __UpperCAmelCase				:      Optional[Any]	 =    PrepareForLaunch(__lowerCamelCase    ,						distributed_type="""TPU"""						)
    print(f"""Launching a training on {num_processes} TPU cores."""						)
    xmp.spawn(__lowerCamelCase    ,						args=__lowerCamelCase    ,						nprocs=__lowerCamelCase    ,						start_method="""fork"""						)
  elif in_colab:
    # No need for a distributed launch otherwise as it's either CPU or one GPU.
    if torch.cuda.is_available():
      print("""Launching training on one GPU."""						)
    else:
      print("""Launching training on one CPU."""						)
    function(*__lowerCamelCase						)
  else:
    if num_processes is None:
      raise ValueError(
          """You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call."""						)

    if num_processes > 1:
      # Multi-GPU launch
      from torch.multiprocessing import start_processes
      from torch.multiprocessing.spawn import ProcessRaisedException

      if len(AcceleratorState._shared_state						) > 0:
        raise ValueError(
            """To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized """
            """inside your training function. Restart your notebook and make sure no cells initializes an """
            """`Accelerator`."""						)

      if torch.cuda.is_initialized():
        raise ValueError(
            """To launch a multi-GPU training from your notebook, you need to avoid running any instruction """
            """using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA """
            """function."""						)

      # torch.distributed will expect a few environment variable to be here. We set the ones common to each
      # process here (the other ones will be set be the launcher).
      with patch_environment(
          world_size=__lowerCamelCase    ,						master_addr="""127.0.01"""    ,						master_port=__lowerCamelCase    ,						mixed_precision=__lowerCamelCase						):
        __UpperCAmelCase				:      Dict	 =    PrepareForLaunch(__lowerCamelCase    ,						distributed_type="""MULTI_GPU"""						)
        print(f"""Launching training on {num_processes} GPUs."""						)
        try:
          start_processes(__lowerCamelCase    ,						args=__lowerCamelCase    ,						nprocs=__lowerCamelCase    ,						start_method="""fork"""						)
        except ProcessRaisedException as e:
          if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]:
            raise RuntimeError(
                """CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. """
                """This likely stems from an outside import causing issues once the `notebook_launcher()` is called. """
                """Please review your imports and test them when running the `notebook_launcher()` to identify """
                """which one is problematic."""						) from e

    else:
      # No need for a distributed launch otherwise as it's either CPU, GPU or MPS.
      if is_mps_available():
        __UpperCAmelCase				:      Union[str, Any]	 =    """1"""
        print("""Launching training on MPS."""						)
      elif torch.cuda.is_available():
        print("""Launching training on one GPU."""						)
      else:
        print("""Launching training on CPU."""						)
      function(*__lowerCamelCase						)







def 							lowerCamelCase__ (       __lowerCamelCase     :	str    ,						__lowerCamelCase     :	List[Any]=()    ,						__lowerCamelCase     :	Dict=2						):
  from torch.multiprocessing import start_processes

  with tempfile.NamedTemporaryFile() as tmp_file:
    # torch.distributed will expect a few environment variable to be here. We set the ones common to each
    # process here (the other ones will be set be the launcher).
    with patch_environment(
        world_size=__lowerCamelCase    ,						master_addr="""127.0.01"""    ,						master_port="""29500"""    ,						accelerate_mixed_precision="""no"""    ,						accelerate_debug_rdv_file=tmp_file.name    ,						accelerate_use_cpu="""yes"""    ,						):
      __UpperCAmelCase				:      Tuple	 =    PrepareForLaunch(__lowerCamelCase    ,						debug=__lowerCamelCase						)
      start_processes(__lowerCamelCase    ,						args=__lowerCamelCase    ,						nprocs=__lowerCamelCase    ,						start_method="""fork"""						)






"""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      UpperCAmelCase     (       _lowercase :   str			,   _lowercase :   int			,   _lowercase :   Optional[int]=1E-12	)						-> List[str]:


	"""simple docstring"""




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







class    __a						( nn.Module							):
				lowerCamelCase     :       CLIPConfig
				lowerCamelCase     :       jnp.dtype			       =jnp.floataa







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			FlaxCLIPVisionModule(self.config.vision_config   )
					lowerCAmelCase_      							=			nn.Dense(self.config.projection_dim      ,	use_bias=UpperCAmelCase      ,	dtype=self.dtype   )

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

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







				def __call__( self      ,	UpperCAmelCase   ):

					'''simple docstring'''






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

					lowerCAmelCase_      							=			jax_cosine_distance(UpperCAmelCase      ,	self.special_care_embeds   )
					lowerCAmelCase_      							=			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
					lowerCAmelCase_      							=			0.0

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

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

					return has_nsfw_concepts







class    __a						( __snake_case							):
				lowerCamelCase     :       Optional[Any]			       =CLIPConfig
				lowerCamelCase     :       List[str]			       ='clip_input'
				lowerCamelCase     :       int			       =FlaxStableDiffusionSafetyCheckerModule







				def __init__( self      ,	UpperCAmelCase      ,	UpperCAmelCase = None      ,	UpperCAmelCase = 0      ,	UpperCAmelCase = jnp.floataa      ,	UpperCAmelCase = True      ,	**UpperCAmelCase      ,	):

					'''simple docstring'''






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







				def      lowerCamelCase_     ( self      ,	UpperCAmelCase      ,	UpperCAmelCase      ,	UpperCAmelCase = None   ):

					'''simple docstring'''






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

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

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

					return random_params







				def __call__( self      ,	UpperCAmelCase      ,	UpperCAmelCase = None      ,	):

					'''simple docstring'''






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

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