


# 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       UpperCAmelCase__						(UpperCamelCase_    ):



     """simple docstring"""






     snake_case					=    botoa.client('''iam'''    )

     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    )    )
          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       UpperCAmelCase__						(UpperCamelCase_    ):



     """simple docstring"""






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

def       UpperCAmelCase__						():



     """simple docstring"""






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

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

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

     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:
          snake_case					=    _ask_field('''Enter your IAM role name: '''    )
     else:
          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_    )

     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.'''							,)
     snake_case					=    None
     if is_custom_docker_image:
          snake_case					=    _ask_field('''Enter your Docker image: '''							,lambda UpperCamelCase_    : str(UpperCamelCase_    ).lower()    )

     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.'''							,)
     snake_case					=    None
     if is_sagemaker_inputs_enabled:
          snake_case					=    _ask_field(
              '''Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): '''							,lambda UpperCamelCase_    : str(UpperCamelCase_    ).lower()							,)

     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.'''							,)
     snake_case					=    None
     if is_sagemaker_metrics_enabled:
          snake_case					=    _ask_field(
              '''Enter the path to the SageMaker metrics TSV file with columns (metric_name, metric_regex): '''							,lambda UpperCamelCase_    : str(UpperCamelCase_    ).lower()							,)

     snake_case					=    _ask_options(
         '''What is the distributed mode?'''							,['''No distributed training''', '''Data parallelism''']							,_convert_sagemaker_distributed_mode							,)
     snake_case					=    {}
     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:
          snake_case					=    '''dynamo_'''
          snake_case					=    _ask_options(
              '''Which dynamo backend would you like to use?'''							,[x.lower() for x in DYNAMO_BACKENDS]							,_convert_dynamo_backend							,default=2							,)
          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:
               snake_case					=    _ask_options(
                   '''Which mode do you want to use?'''							,UpperCamelCase_							,lambda UpperCamelCase_    : TORCH_DYNAMO_MODES[int(UpperCamelCase_    )]							,default='''default'''							,)
               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.'''							,)
               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.'''							,)
     snake_case					=    '''Which EC2 instance type you want to use for your training?'''
     if distributed_type != SageMakerDistributedType.NO:
          snake_case					=    _ask_options(
              UpperCamelCase_							,UpperCamelCase_							,lambda UpperCamelCase_    : SAGEMAKER_PARALLEL_EC2_INSTANCES[int(UpperCamelCase_    )]    )
     else:
          eca_instance_query += "? [ml.p3.2xlarge]:"
          snake_case					=    _ask_field(UpperCamelCase_							,lambda UpperCamelCase_    : str(UpperCamelCase_    ).lower()							,default='''ml.p3.2xlarge'''    )

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

     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_							,)








import enum
import warnings

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_tf_available():
 import tensorflow as tf

 from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

if is_torch_available():
 from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

_SCREAMING_SNAKE_CASE      :			Tuple      				=   logging.get_logger(__name__)

class   A__ (   enum.Enum     ):







    """simple docstring"""

    __magic_name__        =		0
    __magic_name__        =		1






@add_end_docstrings(snake_case__     )
class   A__ (   snake_case__     ):







    """simple docstring"""

    __magic_name__        =		'generated'
    def __init__(	self      , *__snake_case      , **__snake_case   ):
         super().__init__(*__snake_case      , **__snake_case   )

         self.check_model_type(
             TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
             if self.framework == '''tf'''
             else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING   )
    def 		a_      (	self      , __snake_case=None      , __snake_case=None      , __snake_case=None      , __snake_case=None      , __snake_case=None      , __snake_case=None      , **__snake_case      , ):
         snake_case					=    {}
         if truncation is not None:
              snake_case					=    truncation

         snake_case					=    generate_kwargs

         snake_case					=    {}
         if return_tensors is not None and return_type is None:
              snake_case					=    ReturnType.TENSORS if return_tensors else ReturnType.TEXT
         if return_type is not None:
              snake_case					=    return_type

         if clean_up_tokenization_spaces is not None:
              snake_case					=    clean_up_tokenization_spaces

         if stop_sequence is not None:
              snake_case					=    self.tokenizer.encode(__snake_case      , add_special_tokens=__snake_case   )
              if len(__snake_case   ) > 1:
                   warnings.warn(
                       '''Stopping on a multiple token sequence is not yet supported on transformers. The first token of'''
                       ''' the stop sequence will be used as the stop sequence string in the interim.'''   )
              snake_case					=    stop_sequence_ids[0]

         return preprocess_params, forward_params, postprocess_params
    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         return True
    def 		a_      (	self      , *__snake_case      , __snake_case   ):
         snake_case					=    self.model.config.prefix if self.model.config.prefix is not None else ''''''
         if isinstance(args[0]      , __snake_case   ):
              if self.tokenizer.pad_token_id is None:
                   raise ValueError('''Please make sure that the tokenizer has a pad_token_id when using a batch input'''   )
              snake_case					=    ([prefix + arg for arg in args[0]],)
              snake_case					=    True

         elif isinstance(args[0]      , __snake_case   ):
              snake_case					=    (prefix + args[0],)
              snake_case					=    False
         else:
              raise ValueError(
                  F''' `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`'''   )
         snake_case					=    self.tokenizer(*__snake_case      , padding=__snake_case      , truncation=__snake_case      , return_tensors=self.framework   )
         # This is produced by tokenizers but is an invalid generate kwargs
         if "token_type_ids" in inputs:
              del inputs["token_type_ids"]
         return inputs
    def __call__(	self      , *__snake_case      , **__snake_case   ):
         snake_case					=    super().__call__(*__snake_case      , **__snake_case   )
         if (
             isinstance(args[0]      , __snake_case   )
             and all(isinstance(__snake_case      , __snake_case   ) for el in args[0]   )
             and all(len(__snake_case   ) == 1 for res in result   )
         ):
              return [res[0] for res in result]
         return result
    def 		a_      (	self      , __snake_case      , __snake_case=TruncationStrategy.DO_NOT_TRUNCATE      , **__snake_case   ):
         snake_case					=    self._parse_and_tokenize(__snake_case      , truncation=__snake_case      , **__snake_case   )
         return inputs
    def 		a_      (	self      , __snake_case      , **__snake_case   ):
         if self.framework == "pt":
              snake_case			,  snake_case					=    model_inputs['''input_ids'''].shape
         elif self.framework == "tf":
              snake_case			,  snake_case					=    tf.shape(model_inputs['''input_ids''']   ).numpy()

         snake_case					=    generate_kwargs.get('''min_length'''      , self.model.config.min_length   )
         snake_case					=    generate_kwargs.get('''max_length'''      , self.model.config.max_length   )
         self.check_inputs(__snake_case      , generate_kwargs['''min_length''']      , generate_kwargs['''max_length''']   )
         snake_case					=    self.model.generate(**__snake_case      , **__snake_case   )
         snake_case					=    output_ids.shape[0]
         if self.framework == "pt":
              snake_case					=    output_ids.reshape(__snake_case      , out_b // in_b      , *output_ids.shape[1:]   )
         elif self.framework == "tf":
              snake_case					=    tf.reshape(__snake_case      , (in_b, out_b // in_b, *output_ids.shape[1:])   )
         return {"output_ids": output_ids}




    def 		a_      (	self      , __snake_case      , __snake_case=ReturnType.TEXT      , __snake_case=False   ):
         snake_case					=    []
         for output_ids in model_outputs["output_ids"][0]:
              if return_type == ReturnType.TENSORS:
                   snake_case					=    {F'''{self.return_name}_token_ids''': output_ids}
              elif return_type == ReturnType.TEXT:
                   snake_case					=    {
                       F'''{self.return_name}_text''': self.tokenizer.decode(
                           __snake_case      , skip_special_tokens=__snake_case      , clean_up_tokenization_spaces=__snake_case      , )
                   }
              records.append(__snake_case   )
         return records






@add_end_docstrings(snake_case__     )
class   A__ (   snake_case__     ):







    """simple docstring"""

    __magic_name__        =		'summary'
    def __call__(	self      , *__snake_case      , **__snake_case   ):
         return super().__call__(*__snake_case      , **__snake_case   )




    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         if max_length < min_length:
              logger.warning(F'''Your min_length={min_length} must be inferior than your max_length={max_length}.'''   )

         if input_length < max_length:
              logger.warning(
                  F'''Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is '''
                  '''a summarization task, where outputs shorter than the input are typically wanted, you might '''
                  F'''consider decreasing max_length manually, e.g. summarizer(\'...\', max_length={input_length//2})'''   )






@add_end_docstrings(snake_case__     )
class   A__ (   snake_case__     ):







    """simple docstring"""

    __magic_name__        =		'translation'
    def 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         if input_length > 0.9 * max_length:
              logger.warning(
                  F'''Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider '''
                  '''increasing your max_length manually, e.g. translator(\'...\', max_length=400)'''   )
         return True
    def 		a_      (	self      , *__snake_case      , __snake_case=TruncationStrategy.DO_NOT_TRUNCATE      , __snake_case=None      , __snake_case=None   ):
         if getattr(self.tokenizer      , '''_build_translation_inputs'''      , __snake_case   ):
              return self.tokenizer._build_translation_inputs(
                  *__snake_case      , return_tensors=self.framework      , truncation=__snake_case      , src_lang=__snake_case      , tgt_lang=__snake_case   )
         else:
              return super()._parse_and_tokenize(*__snake_case      , truncation=__snake_case   )
    def 		a_      (	self      , __snake_case=None      , __snake_case=None      , **__snake_case   ):
         snake_case			,  snake_case			,  snake_case					=    super()._sanitize_parameters(**__snake_case   )
         if src_lang is not None:
              snake_case					=    src_lang
         if tgt_lang is not None:
              snake_case					=    tgt_lang
         if src_lang is None and tgt_lang is None:
              # Backward compatibility, direct arguments use is preferred.
              snake_case					=    kwargs.get('''task'''      , self.task   )
              snake_case					=    task.split('''_'''   )
              if task and len(__snake_case   ) == 4:
                   # translation, XX, to YY
                   snake_case					=    items[1]
                   snake_case					=    items[3]
         return preprocess_params, forward_params, postprocess_params




    def __call__(	self      , *__snake_case      , **__snake_case   ):
         return super().__call__(*__snake_case      , **__snake_case   )




