





'''simple docstring'''

from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
      import PIL


lowercase_					= logging.get_logger(__name__)


class 					a_     (				snake_case_       ):

    '''simple docstring'''
    UpperCamelCase     = ['''pixel_values''']


    def __init__(		self ,		A = True ,		A = None ,		A = PIL.Image.BICUBIC ,		A = True ,		A = None ,		A = 1 / 255 ,		A = True ,		A = True ,		A = None ,		A = None ,		**A ,		)		->   None:
        super().__init__(**UpperCamelCase__       )
        _SCREAMING_SNAKE_CASE									=			size if size is not None else {"height": 256, "width": 256}
        _SCREAMING_SNAKE_CASE									=			get_size_dict(UpperCamelCase__       )
        _SCREAMING_SNAKE_CASE									=			crop_size if crop_size is not None else {"height": 224, "width": 224}
        _SCREAMING_SNAKE_CASE									=			get_size_dict(UpperCamelCase__ ,		param_name="""crop_size"""       )

        _SCREAMING_SNAKE_CASE									=			do_resize
        _SCREAMING_SNAKE_CASE									=			size
        _SCREAMING_SNAKE_CASE									=			resample
        _SCREAMING_SNAKE_CASE									=			do_center_crop
        _SCREAMING_SNAKE_CASE									=			crop_size
        _SCREAMING_SNAKE_CASE									=			do_rescale
        _SCREAMING_SNAKE_CASE									=			rescale_factor
        _SCREAMING_SNAKE_CASE									=			do_normalize
        _SCREAMING_SNAKE_CASE									=			image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
        _SCREAMING_SNAKE_CASE									=			image_std if image_std is not None else IMAGENET_STANDARD_STD


    def 			snake_case_(		self ,		A ,		A ,		A = PIL.Image.BICUBIC ,		A = None ,		**A ,		)		->   np.ndarray:
        _SCREAMING_SNAKE_CASE									=			get_size_dict(UpperCamelCase__       )
        if "height" not in size or "width" not in size:
            raise ValueError(f'The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}'       )
        return resize(
            UpperCamelCase__ ,		size=(size["""height"""], size["""width"""]) ,		resample=UpperCamelCase__ ,		data_format=UpperCamelCase__ ,		**UpperCamelCase__       )


    def 			snake_case_(		self ,		A ,		A ,		A = None ,		**A ,		)		->   np.ndarray:
        _SCREAMING_SNAKE_CASE									=			get_size_dict(UpperCamelCase__       )
        if "height" not in size or "width" not in size:
            raise ValueError(f'The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}'       )
        return center_crop(UpperCamelCase__ ,		size=(size["""height"""], size["""width"""]) ,		data_format=UpperCamelCase__ ,		**UpperCamelCase__       )


    def 			snake_case_(		self ,		A ,		A ,		A = None ,		**A ,		)		->   Tuple:
        return rescale(UpperCamelCase__ ,		scale=UpperCamelCase__ ,		data_format=UpperCamelCase__ ,		**UpperCamelCase__       )


    def 			snake_case_(		self ,		A ,		A ,		A ,		A = None ,		**A ,		)		->   np.ndarray:
        return normalize(UpperCamelCase__ ,		mean=UpperCamelCase__ ,		std=UpperCamelCase__ ,		data_format=UpperCamelCase__ ,		**UpperCamelCase__       )





    def 			snake_case_(		self ,		A ,		A = None ,		A = None ,		A=None ,		A = None ,		A = None ,		A = None ,		A = None ,		A = None ,		A = None ,		A = None ,		A = None ,		A = ChannelDimension.FIRST ,		**A ,		)		->   PIL.Image.Image:
        _SCREAMING_SNAKE_CASE									=			do_resize if do_resize is not None else self.do_resize
        _SCREAMING_SNAKE_CASE									=			resample if resample is not None else self.resample
        _SCREAMING_SNAKE_CASE									=			do_center_crop if do_center_crop is not None else self.do_center_crop
        _SCREAMING_SNAKE_CASE									=			do_rescale if do_rescale is not None else self.do_rescale
        _SCREAMING_SNAKE_CASE									=			rescale_factor if rescale_factor is not None else self.rescale_factor
        _SCREAMING_SNAKE_CASE									=			do_normalize if do_normalize is not None else self.do_normalize
        _SCREAMING_SNAKE_CASE									=			image_mean if image_mean is not None else self.image_mean
        _SCREAMING_SNAKE_CASE									=			image_std if image_std is not None else self.image_std

        _SCREAMING_SNAKE_CASE									=			size if size is not None else self.size
        _SCREAMING_SNAKE_CASE									=			get_size_dict(UpperCamelCase__       )
        _SCREAMING_SNAKE_CASE									=			crop_size if crop_size is not None else self.crop_size
        _SCREAMING_SNAKE_CASE									=			get_size_dict(UpperCamelCase__ ,		param_name="""crop_size"""       )

        _SCREAMING_SNAKE_CASE									=			make_list_of_images(UpperCamelCase__       )

        if not valid_images(UpperCamelCase__       ):
            raise ValueError(
                """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
                """torch.Tensor, tf.Tensor or jax.ndarray."""       )

        if do_resize and size is None or resample is None:
            raise ValueError("""Size and resample must be specified if do_resize is True."""       )

        if do_center_crop and crop_size is None:
            raise ValueError("""Crop size must be specified if do_center_crop is True."""       )

        if do_rescale and rescale_factor is None:
            raise ValueError("""Rescale factor must be specified if do_rescale is True."""       )

        if do_normalize and (image_mean is None or image_std is None):
            raise ValueError("""Image mean and std must be specified if do_normalize is True."""       )

        # All transformations expect numpy arrays.
        _SCREAMING_SNAKE_CASE									=			[to_numpy_array(UpperCamelCase__       ) for image in images]

        if do_resize:
            _SCREAMING_SNAKE_CASE									=			[self.resize(image=UpperCamelCase__ ,		size=UpperCamelCase__ ,		resample=UpperCamelCase__       ) for image in images]

        if do_center_crop:
            _SCREAMING_SNAKE_CASE									=			[self.center_crop(image=UpperCamelCase__ ,		size=UpperCamelCase__       ) for image in images]

        if do_rescale:
            _SCREAMING_SNAKE_CASE									=			[self.rescale(image=UpperCamelCase__ ,		scale=UpperCamelCase__       ) for image in images]

        if do_normalize:
            _SCREAMING_SNAKE_CASE									=			[self.normalize(image=UpperCamelCase__ ,		mean=UpperCamelCase__ ,		std=UpperCamelCase__       ) for image in images]

        _SCREAMING_SNAKE_CASE									=			[to_channel_dimension_format(UpperCamelCase__ ,		UpperCamelCase__       ) for image in images]

        _SCREAMING_SNAKE_CASE									=			{"pixel_values": images}
        return BatchFeature(data=UpperCamelCase__ ,		tensor_type=UpperCamelCase__       )







"""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						(						lowercase  :  List[str] )	->						str:


    """simple docstring"""





    snake_case    :      Optional[int]      					=    botoa.client("iam" )

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







def   __lowerCAmelCase						(						lowercase  :  Dict )	->						Optional[int]:


    """simple docstring"""





    snake_case    :      Any      					=    botoa.client("iam" )
    return iam_client.get_role(RoleName=lowercase )["Role"]["Arn"]







def   __lowerCAmelCase						(						)	->						Union[str, Any]:


    """simple docstring"""





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

        snake_case    :      Optional[int]      					=    _ask_field("AWS Secret Access Key: " )
        snake_case    :      Union[str, Any]      					=    aws_secret_access_key

    snake_case    :      Optional[Any]      					=    _ask_field("Enter your AWS Region: [us-east-1]"						,							default="us-east-1" )
    snake_case    :      List[str]      					=    aws_region

    snake_case    :      List[str]      					=    _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"]						,							lowercase						,							)
    if role_management == 0:
        snake_case    :      Tuple      					=    _ask_field("Enter your IAM role name: " )
    else:
        snake_case    :      Union[str, 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(lowercase )

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

    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=lowercase						,							error_message="Please enter yes or no."						,							)
    snake_case    :      List[str]      					=    None
    if is_sagemaker_inputs_enabled:
        snake_case    :      Dict      					=    _ask_field(
            "Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): "						,							lambda lowercase : str(lowercase ).lower()						,							)

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

    snake_case    :      str      					=    _ask_options(
        "What is the distributed mode?"						,							["No distributed training", "Data parallelism"]						,							_convert_sagemaker_distributed_mode						,							)
    snake_case    :      Tuple      					=    {}
    snake_case    :      Any      					=    _ask_field(
        "Do you wish to optimize your script with torch dynamo?[yes/NO]:"						,							_convert_yes_no_to_bool						,							default=lowercase						,							error_message="Please enter yes or no."						,							)
    if use_dynamo:
        snake_case    :      Any      					=    "dynamo_"
        snake_case    :      Optional[int]      					=    _ask_options(
            "Which dynamo backend would you like to use?"						,							[x.lower() for x in DYNAMO_BACKENDS]						,							_convert_dynamo_backend						,							default=2						,							)
        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=lowercase						,							error_message="Please enter yes or no."						,							)

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

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

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





