

'''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    lowerCamelCase__		(    SCREAMING_SNAKE_CASE   : int    ):
  UpperCAmelCase    				=						botoa.client('iam'    )

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


def    lowerCamelCase__		(    SCREAMING_SNAKE_CASE   : List[Any]    ):
  UpperCAmelCase    				=						botoa.client('iam'    )
  return iam_client.get_role(RoleName=SCREAMING_SNAKE_CASE    )["Role"]["Arn"]



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

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

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

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

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

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

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

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

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

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

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





'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


_a					:			Dict							=    {
    'configuration_xlm': ['XLM_PRETRAINED_CONFIG_ARCHIVE_MAP', 'XLMConfig', 'XLMOnnxConfig'],
    'tokenization_xlm': ['XLMTokenizer'],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _a					:			Optional[Any]							=    [
      'XLM_PRETRAINED_MODEL_ARCHIVE_LIST',
      'XLMForMultipleChoice',
      'XLMForQuestionAnswering',
      'XLMForQuestionAnsweringSimple',
      'XLMForSequenceClassification',
      'XLMForTokenClassification',
      'XLMModel',
      'XLMPreTrainedModel',
      'XLMWithLMHeadModel',
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _a					:			int							=    [
      'TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST',
      'TFXLMForMultipleChoice',
      'TFXLMForQuestionAnsweringSimple',
      'TFXLMForSequenceClassification',
      'TFXLMForTokenClassification',
      'TFXLMMainLayer',
      'TFXLMModel',
      'TFXLMPreTrainedModel',
      'TFXLMWithLMHeadModel',
  ]


if TYPE_CHECKING:
  from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
  from .tokenization_xlm import XLMTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_xlm import (
        XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        XLMForMultipleChoice,
        XLMForQuestionAnswering,
        XLMForQuestionAnsweringSimple,
        XLMForSequenceClassification,
        XLMForTokenClassification,
        XLMModel,
        XLMPreTrainedModel,
        XLMWithLMHeadModel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_xlm import (
        TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFXLMForMultipleChoice,
        TFXLMForQuestionAnsweringSimple,
        TFXLMForSequenceClassification,
        TFXLMForTokenClassification,
        TFXLMMainLayer,
        TFXLMModel,
        TFXLMPreTrainedModel,
        TFXLMWithLMHeadModel,
    )

else:
  import sys

  _a					:			Union[str, Any]							=    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


