





# 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 (			_UpperCAmelCase					)     ->	Optional[int]:
    lowerCamelCase__       : Any   					=						botoa.client('iam'					)

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


def 			SCREAMING_SNAKE_CASE (			_UpperCAmelCase					)     ->	Dict:
    lowerCamelCase__       : Optional[int]   					=						botoa.client('iam'					)
    return iam_client.get_role(RoleName=_UpperCAmelCase					)["Role"]["Arn"]


def 			SCREAMING_SNAKE_CASE (			)     ->	int:
    lowerCamelCase__       : List[str]   					=						_ask_options(
        'How do you want to authorize?'		,      ['AWS Profile', 'Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) ']		,      _UpperCAmelCase		,      )
    lowerCamelCase__       : str   					=						None
    if credentials_configuration == 0:
        lowerCamelCase__       : List[Any]   					=						_ask_field('Enter your AWS Profile name: [default] '		,      default='default'					)
        lowerCamelCase__       : 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`'					)
        lowerCamelCase__       : Optional[int]   					=						_ask_field('AWS Access Key ID: '					)
        lowerCamelCase__       : Tuple   					=						aws_access_key_id

        lowerCamelCase__       : Union[str, Any]   					=						_ask_field('AWS Secret Access Key: '					)
        lowerCamelCase__       : str   					=						aws_secret_access_key

    lowerCamelCase__       : Tuple   					=						_ask_field('Enter your AWS Region: [us-east-1]'		,      default='us-east-1'					)
    lowerCamelCase__       : Optional[Any]   					=						aws_region

    lowerCamelCase__       : Optional[int]   					=						_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']		,      _UpperCAmelCase		,      )
    if role_management == 0:
        lowerCamelCase__       : Tuple   					=						_ask_field('Enter your IAM role name: '					)
    else:
        lowerCamelCase__       : Union[str, Any]   					=						'accelerate_sagemaker_execution_role'
        print(F"""Accelerate will create an iam role \"{iam_role_name}\" using the provided credentials"""					)
        _create_iam_role_for_sagemaker(_UpperCAmelCase					)

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

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

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

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

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

    lowerCamelCase__       : Dict   					=						1
    if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL):
        lowerCamelCase__       : Union[str, Any]   					=						_ask_field(
            'How many machines do you want use? [1]: '		,      _UpperCAmelCase		,      default=1		,      )

    lowerCamelCase__       : Tuple   					=						_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=_UpperCAmelCase		,      compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER		,      distributed_type=_UpperCAmelCase		,      use_cpu=_UpperCAmelCase		,      dynamo_config=_UpperCAmelCase		,      eca_instance_type=_UpperCAmelCase		,      profile=_UpperCAmelCase		,      region=_UpperCAmelCase		,      iam_role_name=_UpperCAmelCase		,      mixed_precision=_UpperCAmelCase		,      num_machines=_UpperCAmelCase		,      sagemaker_inputs_file=_UpperCAmelCase		,      sagemaker_metrics_file=_UpperCAmelCase		,      )












from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow


if is_tf_available():
    import tensorflow as tf

    from transformers import AutoTokenizer, TFAutoModelForSeqaSeqLM

@require_tf
@require_sentencepiece
@require_tokenizers
class   lowerCAmelCase				(   unittest.TestCase     ):
 @slow
 def 	A_      ( self    : int      )     ->      Optional[Any]:
     lowerCamelCase__       : Tuple   					=						TFAutoModelForSeqaSeqLM.from_pretrained('google/mt5-small'      )
     lowerCamelCase__       : Any   					=						AutoTokenizer.from_pretrained('google/mt5-small'      )

     lowerCamelCase__       : int   					=						tokenizer('Hello there'     ,	return_tensors='tf'      ).input_ids
     lowerCamelCase__       : int   					=						tokenizer('Hi I am'     ,	return_tensors='tf'      ).input_ids

     lowerCamelCase__       : List[str]   					=						model(UpperCAmelCase     ,	labels=UpperCAmelCase      ).loss
     lowerCamelCase__       : List[Any]   					=						-tf.math.reduce_mean(UpperCAmelCase      ).numpy()

     lowerCamelCase__       : Dict   					=						-2_1.2_2_8_1_6_8
     self.assertTrue(abs(mtf_score - EXPECTED_SCORE      ) < 2e-4      )





