

'''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    A_  ( snake_case ):
  SCREAMING_SNAKE_CASE:Optional[int]						      =					botoa.client("iam" )

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





def    A_  ( snake_case ):
  SCREAMING_SNAKE_CASE:Optional[Any]						      =					botoa.client("iam" )
  return iam_client.get_role(RoleName=snake_case )["Role"]["Arn"]





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

    SCREAMING_SNAKE_CASE:str						      =					_ask_field("AWS Secret Access Key: " )
    SCREAMING_SNAKE_CASE:List[str]						      =					aws_secret_access_key

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

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

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

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

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

  SCREAMING_SNAKE_CASE:int						      =					_ask_options(
      "What is the distributed mode?"      ,       ["No distributed training", "Data parallelism"]      ,       _convert_sagemaker_distributed_mode      ,       )
  SCREAMING_SNAKE_CASE:Union[str, Any]						      =					{}
  SCREAMING_SNAKE_CASE:str						      =					_ask_field(
      "Do you wish to optimize your script with torch dynamo?[yes/NO]:"      ,       _convert_yes_no_to_bool      ,       default=snake_case      ,       error_message="Please enter yes or no."      ,       )
  if use_dynamo:
    SCREAMING_SNAKE_CASE:Dict						      =					"dynamo_"
    SCREAMING_SNAKE_CASE:Optional[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:Optional[int]						      =					_ask_field(
        "Do you want to customize the defaults sent to torch.compile? [yes/NO]: "      ,       _convert_yes_no_to_bool      ,       default=snake_case      ,       error_message="Please enter yes or no."      ,       )

    if use_custom_options:
      SCREAMING_SNAKE_CASE:List[Any]						      =					_ask_options(
          "Which mode do you want to use?"      ,       snake_case      ,       lambda snake_case : TORCH_DYNAMO_MODES[int(snake_case )]      ,       default="default"      ,       )
      SCREAMING_SNAKE_CASE: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=snake_case      ,       error_message="Please enter yes or no."      ,       )
      SCREAMING_SNAKE_CASE:List[Any]						      =					_ask_field(
          "Do you want to enable dynamic shape tracing? [yes/NO]: "      ,       _convert_yes_no_to_bool      ,       default=snake_case      ,       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(
        snake_case      ,       snake_case      ,       lambda snake_case : SAGEMAKER_PARALLEL_EC2_INSTANCES[int(snake_case )] )
  else:
    eca_instance_query += "? [ml.p3.2xlarge]:"
    SCREAMING_SNAKE_CASE:Tuple						      =					_ask_field(snake_case      ,       lambda snake_case : str(snake_case ).lower()      ,       default="ml.p3.2xlarge" )

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

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









'''simple docstring'''

import PIL.Image
import PIL.ImageOps
from packaging import version
from PIL import Image


if version.parse(version.parse(PIL.__version__).base_version) >= version.parse("9.1.0"):
    A_       						=							{
        "linear": PIL.Image.Resampling.BILINEAR,
        "bilinear": PIL.Image.Resampling.BILINEAR,
        "bicubic": PIL.Image.Resampling.BICUBIC,
        "lanczos": PIL.Image.Resampling.LANCZOS,
        "nearest": PIL.Image.Resampling.NEAREST,
    }
else:
    A_       						=							{
        "linear": PIL.Image.LINEAR,
        "bilinear": PIL.Image.BILINEAR,
        "bicubic": PIL.Image.BICUBIC,
        "lanczos": PIL.Image.LANCZOS,
        "nearest": PIL.Image.NEAREST,
    }





def    A_  ( snake_case ):
  SCREAMING_SNAKE_CASE:Any						      =					(images / 2 + 0.5).clamp(0      ,       1 )
  SCREAMING_SNAKE_CASE:Optional[Any]						      =					images.cpu().permute(0      ,       2      ,       3      ,       1 ).float().numpy()
  SCREAMING_SNAKE_CASE:str						      =					numpy_to_pil(snake_case )
  return images





def    A_  ( snake_case ):
  if images.ndim == 3:
    SCREAMING_SNAKE_CASE:List[str]						      =					images[None, ...]
  SCREAMING_SNAKE_CASE:List[Any]						      =					(images * 255).round().astype("uint8" )
  if images.shape[-1] == 1:
    # special case for grayscale (single channel) images
    SCREAMING_SNAKE_CASE:Any						      =					[Image.fromarray(image.squeeze()      ,       mode="L" ) for image in images]
  else:
    SCREAMING_SNAKE_CASE:int						      =					[Image.fromarray(snake_case ) for image in images]

  return pil_images






