





"""simple docstring"""




import json
import os

from ...utils.constants import SAGEMAKER_PARALLEL_EC2_INSTANCES, TORCH_DYNAMO_MODES
from ...utils.dataclasses import ComputeEnvironment, SageMakerDistributedType
from ...utils.imports import is_botoa_available
from .config_args import SageMakerConfig
from .config_utils import (
    DYNAMO_BACKENDS,
    _ask_field,
    _ask_options,
    _convert_dynamo_backend,
    _convert_mixed_precision,
    _convert_sagemaker_distributed_mode,
    _convert_yes_no_to_bool,
)


if is_botoa_available():
		import botoa  # noqa: F401






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       int   )					->str:






	'''simple docstring'''






	a :						Optional[int]      =							botoa.client("iam"   )

	a :						Optional[int]      =							{
	    "Version": "2012-10-17",
	    "Statement": [
	        {"Effect": "Allow", "Principal": {"Service": "sagemaker.amazonaws.com"}, "Action": "sts:AssumeRole"}
	    ],
	}
	try:
		# create the role, associated with the chosen trust policy
		iam_client.create_role(
		    RoleName=_lowercase       ,			AssumeRolePolicyDocument=json.dumps(_lowercase       ,			indent=2   )   )
		a :						str      =							{
		    "Version": "2012-10-17",
		    "Statement": [
		        {
		            "Effect": "Allow",
		            "Action": [
		                "sagemaker:*",
		                "ecr:GetDownloadUrlForLayer",
		                "ecr:BatchGetImage",
		                "ecr:BatchCheckLayerAvailability",
		                "ecr:GetAuthorizationToken",
		                "cloudwatch:PutMetricData",
		                "cloudwatch:GetMetricData",
		                "cloudwatch:GetMetricStatistics",
		                "cloudwatch:ListMetrics",
		                "logs:CreateLogGroup",
		                "logs:CreateLogStream",
		                "logs:DescribeLogStreams",
		                "logs:PutLogEvents",
		                "logs:GetLogEvents",
		                "s3:CreateBucket",
		                "s3:ListBucket",
		                "s3:GetBucketLocation",
		                "s3:GetObject",
		                "s3:PutObject",
		            ],
		            "Resource": "*",
		        }
		    ],
		}
		# attach policy to role
		iam_client.put_role_policy(
		    RoleName=_lowercase       ,			PolicyName=F"""{role_name}_policy_permission"""       ,			PolicyDocument=json.dumps(_lowercase       ,			indent=2   )       ,			)
	except iam_client.exceptions.EntityAlreadyExistsException:
		print(F"""role {role_name} already exists. Using existing one"""   )






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       Optional[Any]   )					->List[str]:






	'''simple docstring'''






	a :						List[str]      =							botoa.client("iam"   )
	return iam_client.get_role(RoleName=_lowercase   )["Role"]["Arn"]







def  _SCREAMING_SNAKE_CASE						(      )					->List[str]:






	'''simple docstring'''






	a :						Optional[Any]      =							_ask_options(
	    "How do you want to authorize?"       ,			["AWS Profile", "Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) "]       ,			_lowercase       ,			)
	a :						Union[str, Any]      =							None
	if credentials_configuration == 0:
		a :						Union[str, Any]      =							_ask_field("Enter your AWS Profile name: [default] "       ,			default="default"   )
		a :						Optional[Any]      =							aws_profile
	else:
		print(
		    "Note you will need to provide AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY when you launch you training script with,"
		    "`accelerate launch --aws_access_key_id XXX --aws_secret_access_key YYY`"   )
		a :						str      =							_ask_field("AWS Access Key ID: "   )
		a :						Dict      =							aws_access_key_id

		a :						Optional[Any]      =							_ask_field("AWS Secret Access Key: "   )
		a :						List[str]      =							aws_secret_access_key

	a :						str      =							_ask_field("Enter your AWS Region: [us-east-1]"       ,			default="us-east-1"   )
	a :						str      =							aws_region

	a :						Tuple      =							_ask_options(
	    "Do you already have an IAM Role for executing Amazon SageMaker Training Jobs?"       ,			["Provide IAM Role name", "Create new IAM role using credentials"]       ,			_lowercase       ,			)
	if role_management == 0:
		a :						int      =							_ask_field("Enter your IAM role name: "   )
	else:
		a :						int      =							"accelerate_sagemaker_execution_role"
		print(F"""Accelerate will create an iam role \"{iam_role_name}\" using the provided credentials"""   )
		_create_iam_role_for_sagemaker(_lowercase   )

	a :						List[str]      =							_ask_field(
	    "Do you want to use custom Docker image? [yes/NO]: "       ,			_convert_yes_no_to_bool       ,			default=_lowercase       ,			error_message="Please enter yes or no."       ,			)
	a :						Any      =							None
	if is_custom_docker_image:
		a :						Union[str, Any]      =							_ask_field("Enter your Docker image: "       ,			lambda _lowercase   : str(_lowercase   ).lower()   )

	a :						Optional[Any]      =							_ask_field(
	    "Do you want to provide SageMaker input channels with data locations? [yes/NO]: "       ,			_convert_yes_no_to_bool       ,			default=_lowercase       ,			error_message="Please enter yes or no."       ,			)
	a :						Any      =							None
	if is_sagemaker_inputs_enabled:
		a :						Any      =							_ask_field(
		    "Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): "       ,			lambda _lowercase   : str(_lowercase   ).lower()       ,			)

	a :						str      =							_ask_field(
	    "Do you want to enable SageMaker metrics? [yes/NO]: "       ,			_convert_yes_no_to_bool       ,			default=_lowercase       ,			error_message="Please enter yes or no."       ,			)
	a :						Dict      =							None
	if is_sagemaker_metrics_enabled:
		a :						int      =							_ask_field(
		    "Enter the path to the SageMaker metrics TSV file with columns (metric_name, metric_regex): "       ,			lambda _lowercase   : str(_lowercase   ).lower()       ,			)

	a :						Tuple      =							_ask_options(
	    "What is the distributed mode?"       ,			["No distributed training", "Data parallelism"]       ,			_convert_sagemaker_distributed_mode       ,			)
	a :						Optional[Any]      =							{}
	a :						int      =							_ask_field(
	    "Do you wish to optimize your script with torch dynamo?[yes/NO]:"       ,			_convert_yes_no_to_bool       ,			default=_lowercase       ,			error_message="Please enter yes or no."       ,			)
	if use_dynamo:
		a :						str      =							"dynamo_"
		a :						Optional[Any]      =							_ask_options(
		    "Which dynamo backend would you like to use?"       ,			[x.lower() for x in DYNAMO_BACKENDS]       ,			_convert_dynamo_backend       ,			default=2       ,			)
		a :						Dict      =							_ask_field(
		    "Do you want to customize the defaults sent to torch.compile? [yes/NO]: "       ,			_convert_yes_no_to_bool       ,			default=_lowercase       ,			error_message="Please enter yes or no."       ,			)

		if use_custom_options:
			a :						List[str]      =							_ask_options(
			    "Which mode do you want to use?"       ,			_lowercase       ,			lambda _lowercase   : TORCH_DYNAMO_MODES[int(_lowercase   )]       ,			default="default"       ,			)
			a :						int      =							_ask_field(
			    "Do you want the fullgraph mode or it is ok to break model into several subgraphs? [yes/NO]: "       ,			_convert_yes_no_to_bool       ,			default=_lowercase       ,			error_message="Please enter yes or no."       ,			)
			a :						List[Any]      =							_ask_field(
			    "Do you want to enable dynamic shape tracing? [yes/NO]: "       ,			_convert_yes_no_to_bool       ,			default=_lowercase       ,			error_message="Please enter yes or no."       ,			)
	a :						List[Any]      =							"Which EC2 instance type you want to use for your training?"
	if distributed_type != SageMakerDistributedType.NO:
		a :						List[str]      =							_ask_options(
		    _lowercase       ,			_lowercase       ,			lambda _lowercase   : SAGEMAKER_PARALLEL_EC2_INSTANCES[int(_lowercase   )]   )
	else:
		eca_instance_query += "? [ml.p3.2xlarge]:"
		a :						Tuple      =							_ask_field(_lowercase       ,			lambda _lowercase   : str(_lowercase   ).lower()       ,			default="ml.p3.2xlarge"   )

	a :						int      =							1
	if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL):
		a :						Dict      =							_ask_field(
		    "How many machines do you want use? [1]: "       ,			_lowercase       ,			default=1       ,			)

	a :						Any      =							_ask_options(
	    "Do you wish to use FP16 or BF16 (mixed precision)?"       ,			["no", "fp16", "bf16", "fp8"]       ,			_convert_mixed_precision       ,			)

	if use_dynamo and mixed_precision == "no":
		print(
		    "Torch dynamo used without mixed precision requires TF32 to be efficient. Accelerate will enable it by default when launching your scripts."   )

	return SageMakerConfig(
	    image_uri=_lowercase       ,			compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER       ,			distributed_type=_lowercase       ,			use_cpu=_lowercase       ,			dynamo_config=_lowercase       ,			eca_instance_type=_lowercase       ,			profile=_lowercase       ,			region=_lowercase       ,			iam_role_name=_lowercase       ,			mixed_precision=_lowercase       ,			num_machines=_lowercase       ,			sagemaker_inputs_file=_lowercase       ,			sagemaker_metrics_file=_lowercase       ,			)






'''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 _SCREAMING_SNAKE_CASE (A    ,					A    ,					A=1E-12			)			->			str:






       """simple docstring"""







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





      '''simple docstring'''






      lowerCAmelCase__   :	CLIPConfig
      lowerCAmelCase__   :	jnp.dtype       =				jnp.floataa



      def  UpperCamelCase__						(self       :       Union[str, Any]					):

             '''simple docstring'''







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

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

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






      def __call__(self       :       Union[str, Any]  ,		UpperCamelCase       :       Tuple					):

             '''simple docstring'''







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

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

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

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

             return has_nsfw_concepts






class     __lowerCAmelCase		(lowercase_	):





      '''simple docstring'''






      lowerCAmelCase__   :	Union[str, Any]       =				CLIPConfig
      lowerCAmelCase__   :	Optional[int]       =				"""clip_input"""
      lowerCAmelCase__   :	Any       =				FlaxStableDiffusionSafetyCheckerModule



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

             '''simple docstring'''







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



      def  UpperCamelCase__						(self       :       Any  ,		UpperCamelCase       :       jax.random.KeyArray  ,		UpperCamelCase       :       Tuple  ,		UpperCamelCase       :       FrozenDict = None					):

             '''simple docstring'''







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

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

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

             return random_params






      def __call__(self       :       Optional[Any]  ,		UpperCamelCase       :       Tuple  ,		UpperCamelCase       :       dict = None  ,		):

             '''simple docstring'''







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

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




