






'''simple docstring'''



from scipy.stats import pearsonr, spearmanr
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets


__UpperCamelCase      :       Tuple      			=      """\
@inproceedings{wang2019glue,
  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},
  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},
  note={In the Proceedings of ICLR.},
  year={2019}
}
"""

__UpperCamelCase      :       Union[str, Any]      			=      """\
GLUE, the General Language Understanding Evaluation benchmark
(https://gluebenchmark.com/) is a collection of resources for training,
evaluating, and analyzing natural language understanding systems.
"""

__UpperCamelCase      :       Optional[int]      			=      """
Compute GLUE evaluation metric associated to each GLUE dataset.
Args:
    predictions: list of predictions to score.
        Each translation should be tokenized into a list of tokens.
    references: list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
Returns: depending on the GLUE subset, one or several of:
    \"accuracy\": Accuracy
    \"f1\": F1 score
    \"pearson\": Pearson Correlation
    \"spearmanr\": Spearman Correlation
    \"matthews_correlation\": Matthew Correlation
Examples:

    >>> glue_metric = datasets.load_metric('glue', 'sst2')  # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"]
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'mrpc')  # 'mrpc' or 'qqp'
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0, 'f1': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'stsb')
    >>> references = [0., 1., 2., 3., 4., 5.]
    >>> predictions = [0., 1., 2., 3., 4., 5.]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)})
    {'pearson': 1.0, 'spearmanr': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'cola')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'matthews_correlation': 1.0}
"""



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	Optional[int],					SCREAMING_SNAKE_CASE__:	Any    )  ->			str:

   """simple docstring"""
   return float((preds == labels).mean()    )



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	Union[str, Any],					SCREAMING_SNAKE_CASE__:	List[str]    )  ->			str:

   """simple docstring"""
   __a				     =    simple_accuracy(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    )
   __a				     =    float(fa_score(y_true=SCREAMING_SNAKE_CASE__,					y_pred=SCREAMING_SNAKE_CASE__    )    )
   return {
       "accuracy": acc,
       "f1": fa,
   }



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	Union[str, Any],					SCREAMING_SNAKE_CASE__:	str    )  ->			Tuple:

   """simple docstring"""
   __a				     =    float(pearsonr(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    )[0]    )
   __a				     =    float(spearmanr(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    )[0]    )
   return {
       "pearson": pearson_corr,
       "spearmanr": spearman_corr,
   }



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




      def  __UpperCamelCase							(  self      )							->Any:



         '''simple docstring'''
         if self.config_name not in [
             "sst2",
             "mnli",
             "mnli_mismatched",
             "mnli_matched",
             "cola",
             "stsb",
             "mrpc",
             "qqp",
             "qnli",
             "rte",
             "wnli",
             "hans",
         ]:
            raise KeyError(
                'You should supply a configuration name selected in '
                '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
                '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'      )
         return datasets.MetricInfo(
             description=_DESCRIPTION ,   citation=_CITATION ,   inputs_description=_KWARGS_DESCRIPTION ,   features=datasets.Features(
                 {
                     'predictions': datasets.Value('int64' if self.config_name != 'stsb' else 'float32'      ),
                     'references': datasets.Value('int64' if self.config_name != 'stsb' else 'float32'      ),
                 }      ) ,   codebase_urls=[] ,   reference_urls=[] ,   format='numpy' ,   )






      def  __UpperCamelCase							(  self ,   lowerCamelCase ,   lowerCamelCase      )							->Any:



         '''simple docstring'''
         if self.config_name == "cola":
            return {"matthews_correlation": matthews_corrcoef(lowerCamelCase ,   lowerCamelCase      )}
         elif self.config_name == "stsb":
            return pearson_and_spearman(lowerCamelCase ,   lowerCamelCase      )
         elif self.config_name in ["mrpc", "qqp"]:
            return acc_and_fa(lowerCamelCase ,   lowerCamelCase      )
         elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
            return {"accuracy": simple_accuracy(lowerCamelCase ,   lowerCamelCase      )}
         else:
            raise KeyError(
                'You should supply a configuration name selected in '
                '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
                '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'      )







'''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    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	Union[str, Any]    )  ->			List[str]:

   """simple docstring"""
   __a				     =    botoa.client('iam'    )

   __a				     =    {
       '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    )    )
      __a				     =    {
          '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    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	List[str]    )  ->			Optional[Any]:

   """simple docstring"""
   __a				     =    botoa.client('iam'    )
   return iam_client.get_role(RoleName=SCREAMING_SNAKE_CASE__    )["Role"]["Arn"]



def    __UpperCAmelCase	(				)  ->			Any:

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

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

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

   __a				     =    _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:
      __a				     =    _ask_field('Enter your IAM role name: '    )
   else:
      __a				     =    '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__    )

   __a				     =    _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.',					)
   __a				     =    None
   if is_custom_docker_image:
      __a				     =    _ask_field('Enter your Docker image: ',					lambda SCREAMING_SNAKE_CASE__    : str(SCREAMING_SNAKE_CASE__    ).lower()    )

   __a				     =    _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.',					)
   __a				     =    None
   if is_sagemaker_inputs_enabled:
      __a				     =    _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(),					)

   __a				     =    _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.',					)
   __a				     =    None
   if is_sagemaker_metrics_enabled:
      __a				     =    _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(),					)

   __a				     =    _ask_options(
       'What is the distributed mode?',					['No distributed training', 'Data parallelism'],					_convert_sagemaker_distributed_mode,					)
   __a				     =    {}
   __a				     =    _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:
      __a				     =    'dynamo_'
      __a				     =    _ask_options(
          'Which dynamo backend would you like to use?',					[x.lower() for x in DYNAMO_BACKENDS],					_convert_dynamo_backend,					default=2,					)
      __a				     =    _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:
         __a				     =    _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',					)
         __a				     =    _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.',					)
         __a				     =    _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.',					)
   __a				     =    'Which EC2 instance type you want to use for your training?'
   if distributed_type != SageMakerDistributedType.NO:
      __a				     =    _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]:"
      __a				     =    _ask_field(SCREAMING_SNAKE_CASE__,					lambda SCREAMING_SNAKE_CASE__    : str(SCREAMING_SNAKE_CASE__    ).lower(),					default='ml.p3.2xlarge'    )

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

   __a				     =    _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__,					)