

"""simple docstring"""


import argparse
import os
import subprocess

from packaging.version import Version, parse

from accelerate.commands.config.config_args import default_config_file, load_config_from_file


__A						   =			"Run commands across TPU VMs for initial setup before running `accelerate launch`."






def     a__    (    __SCREAMING_SNAKE_CASE=None )	->	Any:


		if subparsers is not None:
				__lowerCAmelCase:       Union[str, Any]          =			subparsers.add_parser("tpu-config"					, description=_description )
		else:
				__lowerCAmelCase:       List[str]          =			argparse.ArgumentParser("Accelerate tpu-config command"					, description=_description )
		# Core arguments
		__lowerCAmelCase:       Dict          =			parser.add_argument_group(
		    "Config Arguments"					, "Arguments that can be configured through `accelerate config`." )
		config_args.add_argument(
		    "--config_file"					, type=_A					, default=_A					, help="Path to the config file to use for accelerate."					, )
		config_args.add_argument(
		    "--tpu_name"					, default=_A					, help="The name of the TPU to use. If not specified, will use the TPU specified in the config file."					, )
		config_args.add_argument(
		    "--tpu_zone"					, default=_A					, help="The zone of the TPU to use. If not specified, will use the zone specified in the config file."					, )
		__lowerCAmelCase:       Optional[Any]          =			parser.add_argument_group("TPU Arguments"					, "Arguments for options ran inside the TPU." )
		pod_args.add_argument(
		    "--use_alpha"					, action="store_true"					, help="Whether to use `gcloud alpha` when running the TPU training script instead of `gcloud`."					, )
		pod_args.add_argument(
		    "--command_file"					, default=_A					, help="The path to the file containing the commands to run on the pod on startup."					, )
		pod_args.add_argument(
		    "--command"					, action="append"					, nargs="+"					, help="A command to run on the pod. Can be passed multiple times."					, )
		pod_args.add_argument(
		    "--install_accelerate"					, action="store_true"					, help="Whether to install accelerate on the pod. Defaults to False."					, )
		pod_args.add_argument(
		    "--accelerate_version"					, default="latest"					, help="The version of accelerate to install on the pod. If not specified, will use the latest pypi version. Specify 'dev' to install from GitHub."					, )
		pod_args.add_argument(
		    "--debug"					, action="store_true"					, help="If set, will print the command that would be run instead of running it." )

		if subparsers is not None:
				parser.set_defaults(func=_A )
		return parser






def     a__    (    __SCREAMING_SNAKE_CASE )	->	int:
		__lowerCAmelCase:       List[str]          =			None

		# Get the default from the config file if it exists.
		if args.config_file is not None or os.path.isfile(_A ):
				__lowerCAmelCase:       Optional[int]          =			load_config_from_file(args.config_file )
				if not args.command_file and defaults.command_file is not None and not args.command:
						__lowerCAmelCase:       int          =			defaults.command_file
				if not args.command and defaults.commands is not None:
						__lowerCAmelCase:       Tuple          =			defaults.commands
				if not args.tpu_name:
						__lowerCAmelCase:       List[str]          =			defaults.tpu_name
				if not args.tpu_zone:
						__lowerCAmelCase:       List[str]          =			defaults.tpu_zone
		if args.accelerate_version == "dev":
				__lowerCAmelCase:       int          =			"git+https://github.com/huggingface/accelerate.git"
		elif args.accelerate_version == "latest":
				__lowerCAmelCase:       Any          =			"accelerate -U"
		elif isinstance(parse(args.accelerate_version )					, _A ):
				__lowerCAmelCase:       Optional[int]          =			F"accelerate=={args.accelerate_version}"

		if not args.command_file and not args.command:
				raise ValueError("You must specify either a command file or a command to run on the pod." )

		if args.command_file:
				with open(args.command_file					, "r" ) as f:
						__lowerCAmelCase:       Any          =			[f.read().splitlines()]

    # To turn list of lists into list of strings
		if isinstance(args.command[0]					, _A ):
				__lowerCAmelCase:       Dict          =			[line for cmd in args.command for line in cmd]
		# Default to the shared folder and install accelerate
		__lowerCAmelCase:       List[Any]          =			["cd /usr/share"]
		if args.install_accelerate:
				new_cmd += [F"pip install {args.accelerate_version}"]
		new_cmd += args.command
		__lowerCAmelCase:       Optional[Any]          =			"; ".join(_A )

		# Then send it to gcloud
		# Eventually try to use google-api-core to do this instead of subprocess
		__lowerCAmelCase:       List[str]          =			["gcloud"]
		if args.use_alpha:
				cmd += ["alpha"]
		cmd += [
		    "compute",
		    "tpus",
		    "tpu-vm",
		    "ssh",
		    args.tpu_name,
		    "--zone",
		    args.tpu_zone,
		    "--command",
		    args.command,
		    "--worker",
		    "all",
		]
		if args.debug:
				print(F"Running {' '.join(_A )}" )
				return
		subprocess.run(_A )
		print("Successfully setup pod." )






def     a__    (    )	->	Dict:
		__lowerCAmelCase:       str          =			tpu_command_parser()
		__lowerCAmelCase:       Optional[int]          =			parser.parse_args()

		tpu_command_launcher(_A )



'''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__							(			_A:					Union[str, Any]      ,   _A:					Tuple      ,   _A:					Any=1e-12 )    ->	str:

		'''simple docstring'''


		lowerCAmelCase   					=  jnp.divide(emb_a.T      ,   jnp.clip(jnp.linalg.norm(_A      ,   axis=1 )      ,   a_min=_A ) ).T
		lowerCAmelCase   					=  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 				a__(					nn.Module	):


			'''simple docstring'''






			UpperCAmelCase_			:     CLIPConfig
			UpperCAmelCase_			:     jnp.dtype      =       jnp.floataa



			def 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  FlaxCLIPVisionModule(self.config.vision_config)
					lowerCAmelCase   					=  nn.Dense(self.config.projection_dim       ,    use_bias=__lowerCAmelCase       ,    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       ,    __lowerCAmelCase):




					"""simple docstring"""


					lowerCAmelCase   					=  self.vision_model(__lowerCAmelCase)[1]
					lowerCAmelCase   					=  self.visual_projection(__lowerCAmelCase)

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

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

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

					return has_nsfw_concepts







class 				a__(					lowerCAmelCase__	):


			'''simple docstring'''






			UpperCAmelCase_			:     int      =       CLIPConfig
			UpperCAmelCase_			:     Any      =       '''clip_input'''
			UpperCAmelCase_			:     List[str]      =       FlaxStableDiffusionSafetyCheckerModule



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




					"""simple docstring"""


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



			def 							a_       (   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase = None):




					"""simple docstring"""


					lowerCAmelCase   					=  jax.random.normal(__lowerCAmelCase       ,    __lowerCAmelCase)

					lowerCAmelCase					,     lowerCAmelCase   					=  jax.random.split(__lowerCAmelCase)
					lowerCAmelCase   					=  {"""params""": params_rng, """dropout""": dropout_rng}

					lowerCAmelCase   					=  self.module.init(__lowerCAmelCase       ,    __lowerCAmelCase)["""params"""]

					return random_params







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




					"""simple docstring"""


					lowerCAmelCase   					=  jnp.transpose(__lowerCAmelCase       ,    (0, 2, 3, 1))

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




