





"""simple docstring"""




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       _SCREAMING_SNAKE_CASE		(	_lowercase						:    Tuple					) ->Optional[Any]:






	'''simple docstring'''






	a      :		List[Any]	=				botoa.client("iam"					)

	a      :		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					)					)
		a      :		Union[str, 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       _SCREAMING_SNAKE_CASE		(	_lowercase						:    int					) ->Optional[int]:






	'''simple docstring'''






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







def       _SCREAMING_SNAKE_CASE		(	) ->int:






	'''simple docstring'''






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

		a      :		List[Any]	=				_ask_field("AWS Secret Access Key: "					)
		a      :		int	=				aws_secret_access_key

	a      :		Any	=				_ask_field("Enter your AWS Region: [us-east-1]"    ,       default="us-east-1"					)
	a      :		int	=				aws_region

	a      :		Union[str, 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"]    ,       _lowerCamelCase    ,       )
	if role_management == 0:
		a      :		Any	=				_ask_field("Enter your IAM role name: "					)
	else:
		a      :		Optional[int]	=				"""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					)

	a      :		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."    ,       )
	a      :		Tuple	=				None
	if is_custom_docker_image:
		a      :		Optional[int]	=				_ask_field("Enter your Docker image: "    ,       lambda _lowercase					: str(_lowerCamelCase					).lower()					)

	a      :		Dict	=				_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."    ,       )
	a      :		Tuple	=				None
	if is_sagemaker_inputs_enabled:
		a      :		str	=				_ask_field(
		    "Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): "    ,       lambda _lowercase					: str(_lowerCamelCase					).lower()    ,       )

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

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

	a      :		int	=				1
	if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL):
		a      :		List[Any]	=				_ask_field(
		    "How many machines do you want use? [1]: "    ,       _lowerCamelCase    ,       default=1    ,       )

	a      :		Optional[Any]	=				_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    ,       )



"""simple docstring"""




from scipy.stats import pearsonr

import datasets


_a      :		str           =   '\nPearson correlation coefficient and p-value for testing non-correlation.\nThe Pearson correlation coefficient measures the linear relationship between two datasets. The calculation of the p-value relies on the assumption that each dataset is normally distributed. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact linear relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases.\nThe p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets.\n'


_a      :		List[str]           =   '\nArgs:\n    predictions (`list` of `int`): Predicted class labels, as returned by a model.\n    references (`list` of `int`): Ground truth labels.\n    return_pvalue (`boolean`): If `True`, returns the p-value, along with the correlation coefficient. If `False`, returns only the correlation coefficient. Defaults to `False`.\n\nReturns:\n    pearsonr (`float`): Pearson correlation coefficient. Minimum possible value is -1. Maximum possible value is 1. Values of 1 and -1 indicate exact linear positive and negative relationships, respectively. A value of 0 implies no correlation.\n    p-value (`float`): P-value, which roughly indicates the probability of an The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. Minimum possible value is 0. Maximum possible value is 1. Higher values indicate higher probabilities.\n\nExamples:\n\n    Example 1-A simple example using only predictions and references.\n        >>> pearsonr_metric = datasets.load_metric("pearsonr")\n        >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5])\n        >>> print(round(results[\'pearsonr\'], 2))\n        -0.74\n\n    Example 2-The same as Example 1, but that also returns the `p-value`.\n        >>> pearsonr_metric = datasets.load_metric("pearsonr")\n        >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5], return_pvalue=True)\n        >>> print(sorted(list(results.keys())))\n        [\'p-value\', \'pearsonr\']\n        >>> print(round(results[\'pearsonr\'], 2))\n        -0.74\n        >>> print(round(results[\'p-value\'], 2))\n        0.15\n'


_a      :		List[Any]           =   '\n@article{2020SciPy-NMeth,\nauthor  = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and\n      Haberland, Matt and Reddy, Tyler and Cournapeau, David and\n      Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and\n      Bright, Jonathan and {van der Walt}, St{\'e}fan J. and\n      Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and\n      Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and\n      Kern, Robert and Larson, Eric and Carey, C J and\n      Polat, Ilhan and Feng, Yu and Moore, Eric W. and\n      {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and\n      Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and\n      Harris, Charles R. and Archibald, Anne M. and\n      Ribeiro, Antonio H. and Pedregosa, Fabian and\n      {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},\ntitle   = {{{SciPy} 1.0: Fundamental Algorithms for Scientific\n      Computing in Python}},\njournal = {Nature Methods},\nyear    = {2020},\nvolume  = {17},\npages   = {261--272},\nadsurl  = {https://rdcu.be/b08Wh},\ndoi = {10.1038/s41592-019-0686-2},\n}\n'
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION    ,	_KWARGS_DESCRIPTION		)
class 						__A							( datasets.Metric		):






     def     __A  (		self  ):
       return datasets.MetricInfo(
           description=_DESCRIPTION				,     citation=_CITATION				,     inputs_description=_KWARGS_DESCRIPTION				,     features=datasets.Features(
               {
                   """predictions""": datasets.Value("""float"""  ),
                   """references""": datasets.Value("""float"""  ),
               }  )				,     reference_urls=["""https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html"""]				,     )






     def     __A  (		self				,     a__				,     a__				,     a__=False  ):
       if return_pvalue:
         _lowerCAmelCase						:       List[Any]  			=     pearsonr(a__				,     a__  )
         return {"pearsonr": results[0], "p-value": results[1]}
       else:
         return {"pearsonr": float(pearsonr(a__				,     a__  )[0]  )}




