



# 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        __a			(   __lowerCAmelCase   )     ->     Optional[Any]:
					SCREAMING_SNAKE_CASE							:     List[Any]						=				botoa.client('iam'   )

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

def        __a			(   __lowerCAmelCase   )     ->     List[Any]:
					SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				botoa.client('iam'   )
					return iam_client.get_role(RoleName=__lowerCAmelCase   )["Role"]["Arn"]



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

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

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

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

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

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

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

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

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

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

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




from datetime import datetime

import matplotlib.pyplot as plt
import torch

def        __a			(   __lowerCAmelCase   )     ->     int:
					for param in module.parameters():
										SCREAMING_SNAKE_CASE							:     List[Any]						=				False

def        __a			(   )     ->     List[str]:
					SCREAMING_SNAKE_CASE							:     List[Any]						=				'cuda' if torch.cuda.is_available() else 'cpu'
					if torch.backends.mps.is_available() and torch.backends.mps.is_built():
										SCREAMING_SNAKE_CASE							:     List[str]						=				'mps'
					if device == "mps":
										print(
										    'WARNING: MPS currently doesn\'t seem to work, and messes up backpropagation without any visible torch'
										    ' errors. I recommend using CUDA on a colab notebook or CPU instead if you\'re facing inexplicable issues'
										    ' with generations.'   )
					return device

def        __a			(   __lowerCAmelCase   )     ->     List[Any]:
					SCREAMING_SNAKE_CASE							:     Optional[int]						=				plt.imshow(__lowerCAmelCase   )
					fig.axes.get_xaxis().set_visible(__lowerCAmelCase   )
					fig.axes.get_yaxis().set_visible(__lowerCAmelCase   )
					plt.show()



def        __a			(   )     ->     Optional[Any]:
					SCREAMING_SNAKE_CASE							:     str						=				datetime.now()
					SCREAMING_SNAKE_CASE							:     Optional[int]						=				current_time.strftime('%H:%M:%S'   )
					return timestamp