'''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       (			UpperCAmelCase__				:  Union[str, Any]		)			->	Tuple:


							'''simple docstring'''






							SCREAMING_SNAKE_CASE__     :List[str]						    = botoa.client('iam'		)

							SCREAMING_SNAKE_CASE__     :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=UpperCAmelCase__				,						AssumeRolePolicyDocument=json.dumps(UpperCAmelCase__				,						indent=2		)		)
														SCREAMING_SNAKE_CASE__     :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    lowerCamelCase       (			UpperCAmelCase__				:  Optional[Any]		)			->	int:


							'''simple docstring'''






							SCREAMING_SNAKE_CASE__     :Any						    = botoa.client('iam'		)
							return iam_client.get_role(RoleName=UpperCAmelCase__		)["Role"]["Arn"]





def    lowerCamelCase       (			)			->	Tuple:


							'''simple docstring'''






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

														SCREAMING_SNAKE_CASE__     :int						    = _ask_field('AWS Secret Access Key: '		)
														SCREAMING_SNAKE_CASE__     :int						    = aws_secret_access_key

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

							SCREAMING_SNAKE_CASE__     :List[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']				,						UpperCAmelCase__				,						)
							if role_management == 0:
														SCREAMING_SNAKE_CASE__     :Tuple						    = _ask_field('Enter your IAM role name: '		)
							else:
														SCREAMING_SNAKE_CASE__     :Optional[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__		)

							SCREAMING_SNAKE_CASE__     :Optional[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.'				,						)
							SCREAMING_SNAKE_CASE__     :List[str]						    = None
							if is_custom_docker_image:
														SCREAMING_SNAKE_CASE__     :List[Any]						    = _ask_field('Enter your Docker image: '				,						lambda UpperCAmelCase__		: str(UpperCAmelCase__		).lower()		)

							SCREAMING_SNAKE_CASE__     :Optional[int]						    = _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.'				,						)
							SCREAMING_SNAKE_CASE__     :Any						    = None
							if is_sagemaker_inputs_enabled:
														SCREAMING_SNAKE_CASE__     :int						    = _ask_field(
														    'Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): '				,						lambda UpperCAmelCase__		: str(UpperCAmelCase__		).lower()				,						)

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

							SCREAMING_SNAKE_CASE__     :str						    = _ask_options(
							    'What is the distributed mode?'				,						['No distributed training', 'Data parallelism']				,						_convert_sagemaker_distributed_mode				,						)
							SCREAMING_SNAKE_CASE__     :Dict						    = {}
							SCREAMING_SNAKE_CASE__     :List[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:
														SCREAMING_SNAKE_CASE__     :int						    = 'dynamo_'
														SCREAMING_SNAKE_CASE__     :List[Any]						    = _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=UpperCAmelCase__				,						error_message='Please enter yes or no.'				,						)

														if use_custom_options:
																					SCREAMING_SNAKE_CASE__     :int						    = _ask_options(
																					    'Which mode do you want to use?'				,						UpperCAmelCase__				,						lambda UpperCAmelCase__		: TORCH_DYNAMO_MODES[int(UpperCAmelCase__		)]				,						default='default'				,						)
																					SCREAMING_SNAKE_CASE__     :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.'				,						)
																					SCREAMING_SNAKE_CASE__     :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.'				,						)
							SCREAMING_SNAKE_CASE__     :Any						    = 'Which EC2 instance type you want to use for your training?'
							if distributed_type != SageMakerDistributedType.NO:
														SCREAMING_SNAKE_CASE__     :str						    = _ask_options(
														    UpperCAmelCase__				,						UpperCAmelCase__				,						lambda UpperCAmelCase__		: SAGEMAKER_PARALLEL_EC2_INSTANCES[int(UpperCAmelCase__		)]		)
							else:
														eca_instance_query += "? [ml.p3.2xlarge]:"
														SCREAMING_SNAKE_CASE__     :List[Any]						    = _ask_field(UpperCAmelCase__				,						lambda UpperCAmelCase__		: str(UpperCAmelCase__		).lower()				,						default='ml.p3.2xlarge'		)

							SCREAMING_SNAKE_CASE__     :List[str]						    = 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]: '				,						UpperCAmelCase__				,						default=1				,						)

							SCREAMING_SNAKE_CASE__     :str						    = _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__				,						)







'''simple docstring'''







import absl  # noqa: F401 # Here to have a nice missing dependency error message early on
import nltk  # noqa: F401 # Here to have a nice missing dependency error message early on
import numpy  # noqa: F401 # Here to have a nice missing dependency error message early on
import six  # noqa: F401 # Here to have a nice missing dependency error message early on
from rouge_score import rouge_scorer, scoring

import datasets


UpperCamelCase_      	=	'''\
@inproceedings{lin-2004-rouge,
    title = "{ROUGE}: A Package for Automatic Evaluation of Summaries",
    author = "Lin, Chin-Yew",
    booktitle = "Text Summarization Branches Out",
    month = jul,
    year = "2004",
    address = "Barcelona, Spain",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W04-1013",
    pages = "74--81",
}
'''

UpperCamelCase_      	=	'''\
ROUGE, or Recall-Oriented Understudy for Gisting Evaluation, is a set of metrics and a software package used for
evaluating automatic summarization and machine translation software in natural language processing.
The metrics compare an automatically produced summary or translation against a reference or a set of references (human-produced) summary or translation.

Note that ROUGE is case insensitive, meaning that upper case letters are treated the same way as lower case letters.

This metrics is a wrapper around Google Research reimplementation of ROUGE:
https://github.com/google-research/google-research/tree/master/rouge
'''

UpperCamelCase_      	=	'''
Calculates average rouge scores for a list of hypotheses and references
Args:
    predictions: list of predictions to score. Each prediction
        should be a string with tokens separated by spaces.
    references: list of reference for each prediction. Each
        reference should be a string with tokens separated by spaces.
    rouge_types: A list of rouge types to calculate.
        Valid names:
        `"rouge{n}"` (e.g. `"rouge1"`, `"rouge2"`) where: {n} is the n-gram based scoring,
        `"rougeL"`: Longest common subsequence based scoring.
        `"rougeLSum"`: rougeLsum splits text using `"\n"`.
        See details in https://github.com/huggingface/datasets/issues/617
    use_stemmer: Bool indicating whether Porter stemmer should be used to strip word suffixes.
    use_aggregator: Return aggregates if this is set to True
Returns:
    rouge1: rouge_1 (precision, recall, f1),
    rouge2: rouge_2 (precision, recall, f1),
    rougeL: rouge_l (precision, recall, f1),
    rougeLsum: rouge_lsum (precision, recall, f1)
Examples:

    >>> rouge = datasets.load_metric(\'rouge\')
    >>> predictions = ["hello there", "general kenobi"]
    >>> references = ["hello there", "general kenobi"]
    >>> results = rouge.compute(predictions=predictions, references=references)
    >>> print(list(results.keys()))
    [\'rouge1\', \'rouge2\', \'rougeL\', \'rougeLsum\']
    >>> print(results["rouge1"])
    AggregateScore(low=Score(precision=1.0, recall=1.0, fmeasure=1.0), mid=Score(precision=1.0, recall=1.0, fmeasure=1.0), high=Score(precision=1.0, recall=1.0, fmeasure=1.0))
    >>> print(results["rouge1"].mid.fmeasure)
    1.0
'''




@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,						_KWARGS_DESCRIPTION					)
class _SCREAMING_SNAKE_CASE(							datasets.Metric					):




						def      __lowerCamelCase       (    self :       Any      )     ->				Union[str, Any]:
													return datasets.MetricInfo(
													    description=_DESCRIPTION							,							citation=_CITATION							,							inputs_description=_KWARGS_DESCRIPTION							,							features=datasets.Features(
													        {
													            'predictions': datasets.Value('string'							,							id='sequence'      ),
													            'references': datasets.Value('string'							,							id='sequence'      ),
													        }      )							,							codebase_urls=['https://github.com/google-research/google-research/tree/master/rouge']							,							reference_urls=[
													        'https://en.wikipedia.org/wiki/ROUGE_(metric)',
													        'https://github.com/google-research/google-research/tree/master/rouge',
													    ]							,							)




						def      __lowerCamelCase       (    self :       Optional[Any]							,							UpperCamelCase_ :       Optional[int]							,							UpperCamelCase_ :       int							,							UpperCamelCase_ :       Tuple=None							,							UpperCamelCase_ :       Tuple=True							,							UpperCamelCase_ :       str=False      )     ->				Optional[Any]:
													if rouge_types is None:
																				SCREAMING_SNAKE_CASE__     :Optional[int]						    = ['rouge1', 'rouge2', 'rougeL', 'rougeLsum']

													SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = rouge_scorer.RougeScorer(rouge_types=UpperCamelCase_							,							use_stemmer=UpperCamelCase_      )
													if use_aggregator:
																				SCREAMING_SNAKE_CASE__     :Tuple						    = scoring.BootstrapAggregator()
													else:
																				SCREAMING_SNAKE_CASE__     :Any						    = []

													for ref, pred in zip(UpperCamelCase_							,							UpperCamelCase_      ):
																				SCREAMING_SNAKE_CASE__     :Tuple						    = scorer.score(UpperCamelCase_							,							UpperCamelCase_      )
																				if use_aggregator:
																											aggregator.add_scores(UpperCamelCase_      )
																				else:
																											scores.append(UpperCamelCase_      )

													if use_aggregator:
																				SCREAMING_SNAKE_CASE__     :Tuple						    = aggregator.aggregate()
													else:
																				SCREAMING_SNAKE_CASE__     :List[str]						    = {}
																				for key in scores[0]:
																											SCREAMING_SNAKE_CASE__     :int						    = [score[key] for score in scores]

													return result






