



# 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      __lowercase       (			a__       )    ->			Tuple:
							__SCREAMING_SNAKE_CASE									= botoa.client('iam'       )

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






def      __lowercase       (			a__       )    ->			int:
							__SCREAMING_SNAKE_CASE									= botoa.client('iam'       )
							return iam_client.get_role(RoleName=a__       )["Role"]["Arn"]






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

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

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

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

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

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

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

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

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

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

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











import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase__		:					Dict							=logging.get_logger(__name__)

lowerCAmelCase__		:					Optional[int]							={
    '''asapp/sew-tiny-100k''': '''https://huggingface.co/asapp/sew-tiny-100k/resolve/main/config.json''',
    # See all SEW models at https://huggingface.co/models?filter=sew
}

class        UpperCAmelCase_  (       UpperCamelCase_	):

						'''simple docstring'''




						UpperCamelCase__      :			Optional[Any]      =  '''sew'''






						def __init__(   self				,							_A=32				,							_A=768				,							_A=12				,							_A=12				,							_A=3_072				,							_A=2				,							_A="gelu"				,							_A=0.1				,							_A=0.1				,							_A=0.1				,							_A=0.0				,							_A=0.1				,							_A=0.1				,							_A=0.0_2				,							_A=1e-5				,							_A="group"				,							_A="gelu"				,							_A=(64, 128, 128, 128, 128, 256, 256, 256, 256, 512, 512, 512, 512)				,							_A=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1)				,							_A=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1)				,							_A=False				,							_A=128				,							_A=16				,							_A=True				,							_A=0.0_5				,							_A=10				,							_A=2				,							_A=0.0				,							_A=10				,							_A=0				,							_A="mean"				,							_A=False				,							_A=False				,							_A=256				,							_A=0				,							_A=1				,							_A=2				,							**_A				,							):







													'''simple docstring'''

													super().__init__(**_A				,							pad_token_id=_A				,							bos_token_id=_A				,							eos_token_id=_A		)
													__SCREAMING_SNAKE_CASE									= hidden_size
													__SCREAMING_SNAKE_CASE									= feat_extract_norm
													__SCREAMING_SNAKE_CASE									= feat_extract_activation
													__SCREAMING_SNAKE_CASE									= list(_A		)
													__SCREAMING_SNAKE_CASE									= list(_A		)
													__SCREAMING_SNAKE_CASE									= list(_A		)
													__SCREAMING_SNAKE_CASE									= conv_bias
													__SCREAMING_SNAKE_CASE									= num_conv_pos_embeddings
													__SCREAMING_SNAKE_CASE									= num_conv_pos_embedding_groups
													__SCREAMING_SNAKE_CASE									= len(self.conv_dim		)
													__SCREAMING_SNAKE_CASE									= num_hidden_layers
													__SCREAMING_SNAKE_CASE									= intermediate_size
													__SCREAMING_SNAKE_CASE									= squeeze_factor
													__SCREAMING_SNAKE_CASE									= hidden_act
													__SCREAMING_SNAKE_CASE									= num_attention_heads
													__SCREAMING_SNAKE_CASE									= hidden_dropout
													__SCREAMING_SNAKE_CASE									= attention_dropout
													__SCREAMING_SNAKE_CASE									= activation_dropout
													__SCREAMING_SNAKE_CASE									= feat_proj_dropout
													__SCREAMING_SNAKE_CASE									= final_dropout
													__SCREAMING_SNAKE_CASE									= layerdrop
													__SCREAMING_SNAKE_CASE									= layer_norm_eps
													__SCREAMING_SNAKE_CASE									= initializer_range
													__SCREAMING_SNAKE_CASE									= vocab_size

													if (
													    (len(self.conv_stride		) != self.num_feat_extract_layers)
													    or (len(self.conv_kernel		) != self.num_feat_extract_layers)
													    or (len(self.conv_dim		) != self.num_feat_extract_layers)
													):
																				raise ValueError(
																				    'Configuration for convolutional layers is incorrect.'
																				    'It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,'
																				    f"""but is `len(config.conv_dim) = {len(self.conv_dim		)}`, `len(config.conv_stride)"""
																				    f"""= {len(self.conv_stride		)}`, `len(config.conv_kernel) = {len(self.conv_kernel		)}`."""		)

													# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
													__SCREAMING_SNAKE_CASE									= apply_spec_augment
													__SCREAMING_SNAKE_CASE									= mask_time_prob
													__SCREAMING_SNAKE_CASE									= mask_time_length
													__SCREAMING_SNAKE_CASE									= mask_time_min_masks
													__SCREAMING_SNAKE_CASE									= mask_feature_prob
													__SCREAMING_SNAKE_CASE									= mask_feature_length
													__SCREAMING_SNAKE_CASE									= mask_feature_min_masks

													# ctc loss
													__SCREAMING_SNAKE_CASE									= ctc_loss_reduction
													__SCREAMING_SNAKE_CASE									= ctc_zero_infinity

													# sequence classification
													__SCREAMING_SNAKE_CASE									= use_weighted_layer_sum
													__SCREAMING_SNAKE_CASE									= classifier_proj_size






						@property
						def 	_A     (   self		):







													'''simple docstring'''

													return functools.reduce(operator.mul				,							self.conv_stride				,							1		)






