

import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


lowerCAmelCase							:  Any   	=						logging.get_logger(__name__)


lowerCAmelCase							:  Tuple   	=						{"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt"""}

lowerCAmelCase							:  Optional[int]   	=						{
    """vocab_file""": {
        """allenai/longformer-base-4096""": """https://huggingface.co/allenai/longformer-base-4096/resolve/main/vocab.json""",
        """allenai/longformer-large-4096""": (
            """https://huggingface.co/allenai/longformer-large-4096/resolve/main/vocab.json"""
        ),
        """allenai/longformer-large-4096-finetuned-triviaqa""": (
            """https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/vocab.json"""
        ),
        """allenai/longformer-base-4096-extra.pos.embd.only""": (
            """https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/vocab.json"""
        ),
        """allenai/longformer-large-4096-extra.pos.embd.only""": (
            """https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/vocab.json"""
        ),
    },
    """merges_file""": {
        """allenai/longformer-base-4096""": """https://huggingface.co/allenai/longformer-base-4096/resolve/main/merges.txt""",
        """allenai/longformer-large-4096""": (
            """https://huggingface.co/allenai/longformer-large-4096/resolve/main/merges.txt"""
        ),
        """allenai/longformer-large-4096-finetuned-triviaqa""": (
            """https://huggingface.co/allenai/longformer-large-4096-finetuned-triviaqa/resolve/main/merges.txt"""
        ),
        """allenai/longformer-base-4096-extra.pos.embd.only""": (
            """https://huggingface.co/allenai/longformer-base-4096-extra.pos.embd.only/resolve/main/merges.txt"""
        ),
        """allenai/longformer-large-4096-extra.pos.embd.only""": (
            """https://huggingface.co/allenai/longformer-large-4096-extra.pos.embd.only/resolve/main/merges.txt"""
        ),
    },
}

lowerCAmelCase							:  Optional[Any]   	=						{
    """allenai/longformer-base-4096""": 4096,
    """allenai/longformer-large-4096""": 4096,
    """allenai/longformer-large-4096-finetuned-triviaqa""": 4096,
    """allenai/longformer-base-4096-extra.pos.embd.only""": 4096,
    """allenai/longformer-large-4096-extra.pos.embd.only""": 4096,
}







@lru_cache()
# Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode
def 			A_      (    ):
						SCREAMING_SNAKE_CASE_: Any  		=       (
						    list(range(ord("!"    )				,	ord("~"    ) + 1    )    ) + list(range(ord("¡"    )				,	ord("¬"    ) + 1    )    ) + list(range(ord("®"    )				,	ord("ÿ"    ) + 1    )    )
						)
						SCREAMING_SNAKE_CASE_: Tuple  		=       bs[:]
						SCREAMING_SNAKE_CASE_: str  		=       0
						for b in range(2**8    ):
												if b not in bs:
																		bs.append(_UpperCAmelCase    )
																		cs.append(2**8 + n    )
																		n += 1
						SCREAMING_SNAKE_CASE_: Optional[int]  		=       [chr(_UpperCAmelCase    ) for n in cs]
						return dict(zip(_UpperCAmelCase				,	_UpperCAmelCase    )    )







def 			A_      (    _UpperCAmelCase    ):
						SCREAMING_SNAKE_CASE_: str  		=       set()
						SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       word[0]
						for char in word[1:]:
												pairs.add((prev_char, char)    )
												SCREAMING_SNAKE_CASE_: Tuple  		=       char
						return pairs



class   __lowercase				( UpperCAmelCase_	):




			"""simple docstring"""







			_UpperCAmelCase   :							Any										=     VOCAB_FILES_NAMES
			_UpperCAmelCase   :							Dict										=     PRETRAINED_VOCAB_FILES_MAP
			_UpperCAmelCase   :							str										=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			_UpperCAmelCase   :							List[str]										=     ['''input_ids''', '''attention_mask''']



			def __init__( self  :     str   ,						lowerCAmelCase__  :     Union[str, Any]   ,						lowerCAmelCase__  :     Optional[int]   ,						lowerCAmelCase__  :     List[Any]="replace"   ,						lowerCAmelCase__  :     Optional[Any]="<s>"   ,						lowerCAmelCase__  :     int="</s>"   ,						lowerCAmelCase__  :     Optional[Any]="</s>"   ,						lowerCAmelCase__  :     int="<s>"   ,						lowerCAmelCase__  :     Optional[Any]="<unk>"   ,						lowerCAmelCase__  :     List[Any]="<pad>"   ,						lowerCAmelCase__  :     Any="<mask>"   ,						lowerCAmelCase__  :     Union[str, Any]=False   ,						**lowerCAmelCase__  :     Tuple   ,						):
									SCREAMING_SNAKE_CASE_: int  		=       AddedToken(lowerCAmelCase__   ,						lstrip=lowerCAmelCase__   ,						rstrip=lowerCAmelCase__) if isinstance(lowerCAmelCase__   ,						lowerCAmelCase__) else bos_token
									SCREAMING_SNAKE_CASE_: str  		=       AddedToken(lowerCAmelCase__   ,						lstrip=lowerCAmelCase__   ,						rstrip=lowerCAmelCase__) if isinstance(lowerCAmelCase__   ,						lowerCAmelCase__) else eos_token
									SCREAMING_SNAKE_CASE_: Optional[int]  		=       AddedToken(lowerCAmelCase__   ,						lstrip=lowerCAmelCase__   ,						rstrip=lowerCAmelCase__) if isinstance(lowerCAmelCase__   ,						lowerCAmelCase__) else sep_token
									SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       AddedToken(lowerCAmelCase__   ,						lstrip=lowerCAmelCase__   ,						rstrip=lowerCAmelCase__) if isinstance(lowerCAmelCase__   ,						lowerCAmelCase__) else cls_token
									SCREAMING_SNAKE_CASE_: int  		=       AddedToken(lowerCAmelCase__   ,						lstrip=lowerCAmelCase__   ,						rstrip=lowerCAmelCase__) if isinstance(lowerCAmelCase__   ,						lowerCAmelCase__) else unk_token
									SCREAMING_SNAKE_CASE_: Any  		=       AddedToken(lowerCAmelCase__   ,						lstrip=lowerCAmelCase__   ,						rstrip=lowerCAmelCase__) if isinstance(lowerCAmelCase__   ,						lowerCAmelCase__) else pad_token

									# Mask token behave like a normal word, i.e. include the space before it
									SCREAMING_SNAKE_CASE_: Optional[int]  		=       AddedToken(lowerCAmelCase__   ,						lstrip=lowerCAmelCase__   ,						rstrip=lowerCAmelCase__) if isinstance(lowerCAmelCase__   ,						lowerCAmelCase__) else mask_token

									super().__init__(
									    errors=lowerCAmelCase__   ,						bos_token=lowerCAmelCase__   ,						eos_token=lowerCAmelCase__   ,						unk_token=lowerCAmelCase__   ,						sep_token=lowerCAmelCase__   ,						cls_token=lowerCAmelCase__   ,						pad_token=lowerCAmelCase__   ,						mask_token=lowerCAmelCase__   ,						add_prefix_space=lowerCAmelCase__   ,						**lowerCAmelCase__   ,						)

									with open(lowerCAmelCase__   ,						encoding="utf-8") as vocab_handle:
															SCREAMING_SNAKE_CASE_: Tuple  		=       json.load(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_: List[str]  		=       {v: k for k, v in self.encoder.items()}
									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       errors  # how to handle errors in decoding
									SCREAMING_SNAKE_CASE_: List[Any]  		=       bytes_to_unicode()
									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       {v: k for k, v in self.byte_encoder.items()}
									with open(lowerCAmelCase__   ,						encoding="utf-8") as merges_handle:
															SCREAMING_SNAKE_CASE_: List[Any]  		=       merges_handle.read().split("\n")[1:-1]
									SCREAMING_SNAKE_CASE_: str  		=       [tuple(merge.split()) for merge in bpe_merges]
									SCREAMING_SNAKE_CASE_: List[Any]  		=       dict(zip(lowerCAmelCase__   ,						range(len(lowerCAmelCase__))))
									SCREAMING_SNAKE_CASE_: str  		=       {}
									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       add_prefix_space

									# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
									SCREAMING_SNAKE_CASE_: List[Any]  		=       re.compile(R"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+")



			@property
			def        _SCREAMING_SNAKE_CASE			( self  :     int):
									return len(self.encoder)



			def        _SCREAMING_SNAKE_CASE			( self  :     int):
									return dict(self.encoder   ,						**self.added_tokens_encoder)



			def        _SCREAMING_SNAKE_CASE			( self  :     str   ,						lowerCAmelCase__  :     List[str]):
									if token in self.cache:
															return self.cache[token]
									SCREAMING_SNAKE_CASE_: Optional[int]  		=       tuple(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_: Optional[int]  		=       get_pairs(lowerCAmelCase__)

									if not pairs:
															return token

									while True:
															SCREAMING_SNAKE_CASE_: int  		=       min(lowerCAmelCase__   ,						key=lambda lowerCAmelCase__: self.bpe_ranks.get(lowerCAmelCase__   ,						float("inf")))
															if bigram not in self.bpe_ranks:
																					break
															SCREAMING_SNAKE_CASE_		,    SCREAMING_SNAKE_CASE_: List[Any]  		=       bigram
															SCREAMING_SNAKE_CASE_: Optional[int]  		=       []
															SCREAMING_SNAKE_CASE_: List[Any]  		=       0
															while i < len(lowerCAmelCase__):
																					try:
																											SCREAMING_SNAKE_CASE_: List[Any]  		=       word.index(lowerCAmelCase__   ,						lowerCAmelCase__)
																					except ValueError:
																											new_word.extend(word[i:])
																											break
																					else:
																											new_word.extend(word[i:j])
																											SCREAMING_SNAKE_CASE_: Tuple  		=       j

																					if word[i] == first and i < len(lowerCAmelCase__) - 1 and word[i + 1] == second:
																											new_word.append(first + second)
																											i += 2
																					else:
																											new_word.append(word[i])
																											i += 1
															SCREAMING_SNAKE_CASE_: str  		=       tuple(lowerCAmelCase__)
															SCREAMING_SNAKE_CASE_: int  		=       new_word
															if len(lowerCAmelCase__) == 1:
																					break
															else:
																					SCREAMING_SNAKE_CASE_: Dict  		=       get_pairs(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       " ".join(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_: Tuple  		=       word
									return word



			def        _SCREAMING_SNAKE_CASE			( self  :     Union[str, Any]   ,						lowerCAmelCase__  :     Tuple):
									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       []
									for token in re.findall(self.pat   ,						lowerCAmelCase__):
															SCREAMING_SNAKE_CASE_: str  		=       "".join(
															    self.byte_encoder[b] for b in token.encode("utf-8"))  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
															bpe_tokens.extend(bpe_token for bpe_token in self.bpe(lowerCAmelCase__).split(" "))
									return bpe_tokens



			def        _SCREAMING_SNAKE_CASE			( self  :     Optional[int]   ,						lowerCAmelCase__  :     Tuple):
									return self.encoder.get(lowerCAmelCase__   ,						self.encoder.get(self.unk_token))



			def        _SCREAMING_SNAKE_CASE			( self  :     str   ,						lowerCAmelCase__  :     Union[str, Any]):
									return self.decoder.get(lowerCAmelCase__)



			def        _SCREAMING_SNAKE_CASE			( self  :     Optional[int]   ,						lowerCAmelCase__  :     Optional[int]):
									SCREAMING_SNAKE_CASE_: Any  		=       "".join(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       bytearray([self.byte_decoder[c] for c in text]).decode("utf-8"   ,						errors=self.errors)
									return text



			def        _SCREAMING_SNAKE_CASE			( self  :     Dict   ,						lowerCAmelCase__  :     str   ,						lowerCAmelCase__  :     Optional[str] = None):
									if not os.path.isdir(lowerCAmelCase__):
															logger.error(F"Vocabulary path ({save_directory}) should be a directory")
															return
									SCREAMING_SNAKE_CASE_: Any  		=       os.path.join(
									    lowerCAmelCase__   ,						(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"])
									SCREAMING_SNAKE_CASE_: Any  		=       os.path.join(
									    lowerCAmelCase__   ,						(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"])

									with open(lowerCAmelCase__   ,						"w"   ,						encoding="utf-8") as f:
															f.write(json.dumps(self.encoder   ,						indent=2   ,						sort_keys=lowerCAmelCase__   ,						ensure_ascii=lowerCAmelCase__) + "\n")

									SCREAMING_SNAKE_CASE_: List[Any]  		=       0
									with open(lowerCAmelCase__   ,						"w"   ,						encoding="utf-8") as writer:
															writer.write("#version: 0.2\n")
															for bpe_tokens, token_index in sorted(self.bpe_ranks.items()   ,						key=lambda lowerCAmelCase__: kv[1]):
																					if index != token_index:
																											logger.warning(
																											    F"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."
																											    " Please check that the tokenizer is not corrupted!")
																											SCREAMING_SNAKE_CASE_: List[Any]  		=       token_index
																					writer.write(" ".join(lowerCAmelCase__) + "\n")
																					index += 1

									return vocab_file, merge_file



			def        _SCREAMING_SNAKE_CASE			( self  :     List[str]   ,						lowerCAmelCase__  :     List[int]   ,						lowerCAmelCase__  :     Optional[List[int]] = None):
									if token_ids_a is None:
															return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
									SCREAMING_SNAKE_CASE_: Optional[int]  		=       [self.cls_token_id]
									SCREAMING_SNAKE_CASE_: Dict  		=       [self.sep_token_id]
									return cls + token_ids_a + sep + sep + token_ids_a + sep



			def        _SCREAMING_SNAKE_CASE			( self  :     Union[str, Any]   ,						lowerCAmelCase__  :     List[int]   ,						lowerCAmelCase__  :     Optional[List[int]] = None   ,						lowerCAmelCase__  :     bool = False):
									if already_has_special_tokens:
															return super().get_special_tokens_mask(
															    token_ids_a=lowerCAmelCase__   ,						token_ids_a=lowerCAmelCase__   ,						already_has_special_tokens=lowerCAmelCase__)

									if token_ids_a is None:
															return [1] + ([0] * len(lowerCAmelCase__)) + [1]
									return [1] + ([0] * len(lowerCAmelCase__)) + [1, 1] + ([0] * len(lowerCAmelCase__)) + [1]



			def        _SCREAMING_SNAKE_CASE			( self  :     Optional[int]   ,						lowerCAmelCase__  :     List[int]   ,						lowerCAmelCase__  :     Optional[List[int]] = None):
									SCREAMING_SNAKE_CASE_: Optional[int]  		=       [self.sep_token_id]
									SCREAMING_SNAKE_CASE_: int  		=       [self.cls_token_id]

									if token_ids_a is None:
															return len(cls + token_ids_a + sep) * [0]
									return len(cls + token_ids_a + sep + sep + token_ids_a + sep) * [0]




			def        _SCREAMING_SNAKE_CASE			( self  :     int   ,						lowerCAmelCase__  :     Union[str, Any]   ,						lowerCAmelCase__  :     List[str]=False   ,						**lowerCAmelCase__  :     str):
									SCREAMING_SNAKE_CASE_: List[Any]  		=       kwargs.pop("add_prefix_space"   ,						self.add_prefix_space)
									if (is_split_into_words or add_prefix_space) and (len(lowerCAmelCase__) > 0 and not text[0].isspace()):
															SCREAMING_SNAKE_CASE_: Optional[Any]  		=       " " + text
									return (text, kwargs)









'''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					(						_UpperCamelCase						:     Optional[int]				)      ->			List[str]:
     """simple docstring"""




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


def        _lowerCAmelCase					(						_UpperCamelCase						:     List[str]				)      ->			Optional[int]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =botoa.client('iam'				)
     return iam_client.get_role(RoleName=_UpperCamelCase				)["Role"]["Arn"]







def        _lowerCAmelCase					(						)      ->			Optional[int]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							    =_ask_options(
         'How do you want to authorize?'							, ['AWS Profile', 'Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) ']							, _UpperCamelCase							, )
     _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']							, _UpperCamelCase							, )
     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(_UpperCamelCase				)

     _SCREAMING_SNAKE_CASE							    =_ask_field(
         'Do you want to use custom Docker image? [yes/NO]: '							, _convert_yes_no_to_bool							, default=_UpperCamelCase							, 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 _UpperCamelCase				: str(_UpperCamelCase				).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=_UpperCamelCase							, 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 _UpperCamelCase				: str(_UpperCamelCase				).lower()							, )

     _SCREAMING_SNAKE_CASE							    =_ask_field(
         'Do you want to enable SageMaker metrics? [yes/NO]: '							, _convert_yes_no_to_bool							, default=_UpperCamelCase							, 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 _UpperCamelCase				: str(_UpperCamelCase				).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=_UpperCamelCase							, 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=_UpperCamelCase							, error_message='Please enter yes or no.'							, )

          if use_custom_options:
               _SCREAMING_SNAKE_CASE							    =_ask_options(
                   'Which mode do you want to use?'							, _UpperCamelCase							, lambda _UpperCamelCase				: TORCH_DYNAMO_MODES[int(_UpperCamelCase				)]							, 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=_UpperCamelCase							, 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=_UpperCamelCase							, 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(
              _UpperCamelCase							, _UpperCamelCase							, lambda _UpperCamelCase				: SAGEMAKER_PARALLEL_EC2_INSTANCES[int(_UpperCamelCase				)]				)
     else:
          eca_instance_query += "? [ml.p3.2xlarge]:"
          _SCREAMING_SNAKE_CASE							    =_ask_field(_UpperCamelCase							, lambda _UpperCamelCase				: str(_UpperCamelCase				).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]: '							, _UpperCamelCase							, 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=_UpperCamelCase							, compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER							, distributed_type=_UpperCamelCase							, use_cpu=_UpperCamelCase							, dynamo_config=_UpperCamelCase							, eca_instance_type=_UpperCamelCase							, profile=_UpperCamelCase							, region=_UpperCamelCase							, iam_role_name=_UpperCamelCase							, mixed_precision=_UpperCamelCase							, num_machines=_UpperCamelCase							, sagemaker_inputs_file=_UpperCamelCase							, sagemaker_metrics_file=_UpperCamelCase							, )
