


'''simple docstring'''

# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
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 (A			)			->			str:






       """simple docstring"""







       lowercase__      =					botoa.client('''iam'''			)

       lowercase__      =					{
           '''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=A    ,					AssumeRolePolicyDocument=json.dumps(A    ,					indent=2			)			)
              lowercase__      =					{
                  '''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=A    ,					PolicyName=f"{role_name}_policy_permission"    ,					PolicyDocument=json.dumps(A    ,					indent=2			)    ,					)
       except iam_client.exceptions.EntityAlreadyExistsException:
              print(f"role {role_name} already exists. Using existing one"			)

def _SCREAMING_SNAKE_CASE (A			)			->			List[str]:






       """simple docstring"""







       lowercase__      =					botoa.client('''iam'''			)
       return iam_client.get_role(RoleName=A			)["Role"]["Arn"]

def _SCREAMING_SNAKE_CASE ()			->			List[str]:






       """simple docstring"""







       lowercase__      =					_ask_options(
           '''How do you want to authorize?'''    ,					['''AWS Profile''', '''Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) ''']    ,					A    ,					)
       lowercase__      =					None
       if credentials_configuration == 0:
              lowercase__      =					_ask_field('''Enter your AWS Profile name: [default] '''    ,					default='''default'''			)
              lowercase__      =					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`'''			)
              lowercase__      =					_ask_field('''AWS Access Key ID: '''			)
              lowercase__      =					aws_access_key_id

              lowercase__      =					_ask_field('''AWS Secret Access Key: '''			)
              lowercase__      =					aws_secret_access_key

       lowercase__      =					_ask_field('''Enter your AWS Region: [us-east-1]'''    ,					default='''us-east-1'''			)
       lowercase__      =					aws_region

       lowercase__      =					_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''']    ,					A    ,					)
       if role_management == 0:
              lowercase__      =					_ask_field('''Enter your IAM role name: '''			)
       else:
              lowercase__      =					'''accelerate_sagemaker_execution_role'''
              print(f"Accelerate will create an iam role \"{iam_role_name}\" using the provided credentials"			)
              _create_iam_role_for_sagemaker(A			)

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

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

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

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

              if use_custom_options:
                     lowercase__      =					_ask_options(
                         '''Which mode do you want to use?'''    ,					A    ,					lambda A			: TORCH_DYNAMO_MODES[int(A			)]    ,					default='''default'''    ,					)
                     lowercase__      =					_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=A    ,					error_message='''Please enter yes or no.'''    ,					)
                     lowercase__      =					_ask_field(
                         '''Do you want to enable dynamic shape tracing? [yes/NO]: '''    ,					_convert_yes_no_to_bool    ,					default=A    ,					error_message='''Please enter yes or no.'''    ,					)
       lowercase__      =					'''Which EC2 instance type you want to use for your training?'''
       if distributed_type != SageMakerDistributedType.NO:
              lowercase__      =					_ask_options(
                  A    ,					A    ,					lambda A			: SAGEMAKER_PARALLEL_EC2_INSTANCES[int(A			)]			)
       else:
              eca_instance_query += "? [ml.p3.2xlarge]:"
              lowercase__      =					_ask_field(A    ,					lambda A			: str(A			).lower()    ,					default='''ml.p3.2xlarge'''			)

       lowercase__      =					1
       if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL):
              lowercase__      =					_ask_field(
                  '''How many machines do you want use? [1]: '''    ,					A    ,					default=1    ,					)

       lowercase__      =					_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=A    ,					compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER    ,					distributed_type=A    ,					use_cpu=A    ,					dynamo_config=A    ,					eca_instance_type=A    ,					profile=A    ,					region=A    ,					iam_role_name=A    ,					mixed_precision=A    ,					num_machines=A    ,					sagemaker_inputs_file=A    ,					sagemaker_metrics_file=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 _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={}  ,		)




