


# 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    lowercase_	(	_A    :					str		):

      """simple docstring"""




      lowerCamelCase__	:       Any					=						botoa.client("iam"		)

      lowerCamelCase__	:       List[str]					=						{
          "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		)		)
            lowerCamelCase__	:       Tuple					=						{
                "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    lowercase_	(	_A    :					Any		):

      """simple docstring"""




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


def    lowercase_	(	):

      """simple docstring"""




      lowerCamelCase__	:       int					=						_ask_options(
          "How do you want to authorize?"					,      ["AWS Profile", "Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) "]					,      _A					,      )
      lowerCamelCase__	:       Tuple					=						None
      if credentials_configuration == 0:
            lowerCamelCase__	:       List[str]					=						_ask_field("Enter your AWS Profile name: [default] "					,      default="default"		)
            lowerCamelCase__	:       Optional[int]					=						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__	:       List[str]					=						aws_access_key_id

            lowerCamelCase__	:       List[Any]					=						_ask_field("AWS Secret Access Key: "		)
            lowerCamelCase__	:       Tuple					=						aws_secret_access_key

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

      lowerCamelCase__	:       Optional[Any]					=						_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:
            lowerCamelCase__	:       Optional[int]					=						_ask_field("Enter your IAM role name: "		)
      else:
            lowerCamelCase__	:       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(_A		)

      lowerCamelCase__	:       str					=						_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."					,      )
      lowerCamelCase__	:       Dict					=						None
      if is_custom_docker_image:
            lowerCamelCase__	:       List[str]					=						_ask_field("Enter your Docker image: "					,      lambda _A		: str(_A		).lower()		)

      lowerCamelCase__	:       Optional[int]					=						_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."					,      )
      lowerCamelCase__	:       Tuple					=						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 _A		: str(_A		).lower()					,      )

      lowerCamelCase__	:       Union[str, Any]					=						_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."					,      )
      lowerCamelCase__	:       List[str]					=						None
      if is_sagemaker_metrics_enabled:
            lowerCamelCase__	:       str					=						_ask_field(
                "Enter the path to the SageMaker metrics TSV file with columns (metric_name, metric_regex): "					,      lambda _A		: str(_A		).lower()					,      )

      lowerCamelCase__	:       Tuple					=						_ask_options(
          "What is the distributed mode?"					,      ["No distributed training", "Data parallelism"]					,      _convert_sagemaker_distributed_mode					,      )
      lowerCamelCase__	:       Optional[int]					=						{}
      lowerCamelCase__	:       Optional[Any]					=						_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:
            lowerCamelCase__	:       List[Any]					=						"dynamo_"
            lowerCamelCase__	:       List[str]					=						_ask_options(
                "Which dynamo backend would you like to use?"					,      [x.lower() for x in DYNAMO_BACKENDS]					,      _convert_dynamo_backend					,      default=2					,      )
            lowerCamelCase__	:       Dict					=						_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:
                  lowerCamelCase__	:       Any					=						_ask_options(
                      "Which mode do you want to use?"					,      _A					,      lambda _A		: TORCH_DYNAMO_MODES[int(_A		)]					,      default="default"					,      )
                  lowerCamelCase__	:       str					=						_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."					,      )
                  lowerCamelCase__	:       Any					=						_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."					,      )
      lowerCamelCase__	:       int					=						"Which EC2 instance type you want to use for your training?"
      if distributed_type != SageMakerDistributedType.NO:
            lowerCamelCase__	:       List[str]					=						_ask_options(
                _A					,      _A					,      lambda _A		: SAGEMAKER_PARALLEL_EC2_INSTANCES[int(_A		)]		)
      else:
            eca_instance_query += "? [ml.p3.2xlarge]:"
            lowerCamelCase__	:       Tuple					=						_ask_field(_A					,      lambda _A		: str(_A		).lower()					,      default="ml.p3.2xlarge"		)

      lowerCamelCase__	:       List[Any]					=						1
      if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL):
            lowerCamelCase__	:       List[Any]					=						_ask_field(
                "How many machines do you want use? [1]: "					,      _A					,      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=_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					,      )






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 numpy as np
    import tensorflow as tf

    from transformers import TFCamembertModel







@require_tf
@require_sentencepiece
@require_tokenizers
class     _lowercase				(							unittest.TestCase):


       """simple docstring"""




       @slow
       def 		lowerCAmelCase  (     self							:    Any ):


             '''simple docstring'''



             lowerCamelCase__	:       Dict					=						TFCamembertModel.from_pretrained("jplu/tf-camembert-base" )

             lowerCamelCase__	:       str					=						tf.convert_to_tensor(
                 [[5, 121, 11, 660, 16, 730, 25543, 110, 83, 6]]      ,   dtype=tf.intaa      ,   )  # J'aime le camembert !"

             lowerCamelCase__	:       Any					=						model(__lowerCamelCase )["last_hidden_state"]
             lowerCamelCase__	:       List[str]					=						tf.TensorShape((1, 10, 768) )
             self.assertEqual(output.shape      ,   __lowerCamelCase )
             # compare the actual values for a slice.
             lowerCamelCase__	:       str					=						tf.convert_to_tensor(
                 [[[-0.0_2_5_4, 0.0_2_3_5, 0.1_0_2_7], [0.0_6_0_6, -0.1_8_1_1, -0.0_4_1_8], [-0.1_5_6_1, -0.1_1_2_7, 0.2_6_8_7]]]      ,   dtype=tf.floataa      ,   )
             # camembert = torch.hub.load('pytorch/fairseq', 'camembert.v0')
             # camembert.eval()
             # expected_slice = roberta.model.forward(input_ids)[0][:, :3, :3].detach()

             self.assertTrue(np.allclose(output[:, :3, :3].numpy()      ,   expected_slice.numpy()      ,   atol=1E-4 ) )


