




'''simple docstring'''






import os

import jsonlines
import numpy as np
from tqdm import tqdm


A_			      =		2048
A_			      =		4096
A_			      =		42
A_			      =		os.environ.pop("PROCESS_TRAIN", "false")
A_			      =		{"null": 0, "short": 1, "long": 2, "yes": 3, "no": 4}






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE		)    ->   Any:
      def choose_first(__SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE=False		):
            assert isinstance(__SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE		)
            if len(__SCREAMING_SNAKE_CASE		) == 1:
                  snake_case__       :   str	      =    answer[0]
                  return {k: [answer[k]] for k in answer} if is_long_answer else answer
            for a in answer:
                  if is_long_answer:
                        snake_case__       :   Any	      =    {k: [a[k]] for k in a}
                  if len(a['start_token']		) > 0:
                        break
            return a

      snake_case__       :   Any	      =    {'id': example['id']}
      snake_case__       :   Dict	      =    example['annotations']
      snake_case__       :   int	      =    annotation['yes_no_answer']
      if 0 in yes_no_answer or 1 in yes_no_answer:
            snake_case__       :   List[Any]	      =    ['yes'] if 1 in yes_no_answer else ['no']
            snake_case__       :   int	      =    []
            snake_case__       :   List[Any]	      =    []
            snake_case__       :   List[str]	      =    ['<cls>']
      else:
            snake_case__       :   int	      =    ['short']
            snake_case__       :   List[str]	      =    choose_first(annotation['short_answers']		)
            if len(out['start_token']		) == 0:
                  # answer will be long if short is not available
                  snake_case__       :   Optional[int]	      =    ['long']
                  snake_case__       :   Dict	      =    choose_first(annotation['long_answer']				,      is_long_answer=__SCREAMING_SNAKE_CASE		)
                  snake_case__       :   Tuple	      =    []
            answer.update(__SCREAMING_SNAKE_CASE		)

      # disregard some samples
      if len(answer['start_token']		) > 1 or answer["start_token"] == answer["end_token"]:
            snake_case__       :   Optional[Any]	      =    True
      else:
            snake_case__       :   Tuple	      =    False

      snake_case__       :   Tuple	      =    ['start_token', 'end_token', 'start_byte', 'end_byte', 'text']
      if not all(isinstance(answer[k]				,      __SCREAMING_SNAKE_CASE		) for k in cols		):
            raise ValueError('Issue in ID'				,      example['id']		)

      return answer






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE=False		)    ->   Dict:
      snake_case__       :   List[Any]	      =    _get_single_answer(__SCREAMING_SNAKE_CASE		)
      # bytes are of no use
      del answer["start_byte"]
      del answer["end_byte"]

      # handle yes_no answers explicitly
      if answer["category"][0] in ["yes", "no"]:  # category is list with one element
            snake_case__       :   Tuple	      =    example['document']['tokens']
            snake_case__       :   List[str]	      =    []
            for i in range(len(doc['token']		)		):
                  if not doc["is_html"][i]:
                        context.append(doc['token'][i]		)
            return {
                "context": " ".join(__SCREAMING_SNAKE_CASE		),
                "answer": {
                    "start_token": -100,  # ignore index in cross-entropy
                    "end_token": -100,  # ignore index in cross-entropy
                    "category": answer["category"],
                    "span": answer["category"],  # extra
                },
            }

      # later, help in removing all no answers
      if answer["start_token"] == [-1]:
            return {
                "context": "None",
                "answer": {
                    "start_token": -1,
                    "end_token": -1,
                    "category": "null",
                    "span": "None",  # extra
                },
            }

      # handling normal samples

      snake_case__       :   Optional[Any]	      =    ['start_token', 'end_token']
      answer.update({k: answer[k][0] if len(answer[k]		) > 0 else answer[k] for k in cols}		)  # e.g. [10] == 10

      snake_case__       :   Optional[int]	      =    example['document']['tokens']
      snake_case__       :   Optional[int]	      =    answer['start_token']
      snake_case__       :   List[Any]	      =    answer['end_token']

      snake_case__       :   Union[str, Any]	      =    []
      for i in range(len(doc['token']		)		):
            if not doc["is_html"][i]:
                  context.append(doc['token'][i]		)
            else:
                  if answer["start_token"] > i:
                        start_token -= 1
                  if answer["end_token"] > i:
                        end_token -= 1
      snake_case__       :   Union[str, Any]	      =    ' '.join(context[start_token:end_token]		)

      # checking above code
      if assertion:
            snake_case__       :   List[str]	      =    doc['is_html'][answer['start_token'] : answer['end_token']]
            snake_case__       :   Any	      =    doc['token'][answer['start_token'] : answer['end_token']]
            snake_case__       :   str	      =    ' '.join([old[i] for i in range(len(__SCREAMING_SNAKE_CASE		)		) if not is_html[i]]		)
            if new != old:
                  print('ID:'				,      example['id']		)
                  print('New:'				,      __SCREAMING_SNAKE_CASE				,      end='\n'		)
                  print('Old:'				,      __SCREAMING_SNAKE_CASE				,      end='\n\n'		)

      return {
          "context": " ".join(__SCREAMING_SNAKE_CASE		),
          "answer": {
              "start_token": start_token,
              "end_token": end_token - 1,  # this makes it inclusive
              "category": answer["category"],  # either long or short
              "span": new,  # extra
          },
      }






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE=2048				,      __SCREAMING_SNAKE_CASE=4096				,      __SCREAMING_SNAKE_CASE=True		)    ->   Union[str, Any]:
      # overlap will be of doc_stride - q_len

      snake_case__       :   Tuple	      =    get_context_and_ans(__SCREAMING_SNAKE_CASE				,      assertion=__SCREAMING_SNAKE_CASE		)
      snake_case__       :   List[Any]	      =    out['answer']

      # later, removing these samples
      if answer["start_token"] == -1:
            return {
                "example_id": example["id"],
                "input_ids": [[-1]],
                "labels": {
                    "start_token": [-1],
                    "end_token": [-1],
                    "category": ["null"],
                },
            }

      snake_case__       :   Optional[Any]	      =    tokenizer(example['question']['text']				,      out['context']		).input_ids
      snake_case__       :   Union[str, Any]	      =    input_ids.index(tokenizer.sep_token_id		) + 1

      # return yes/no
      if answer["category"][0] in ["yes", "no"]:  # category is list with one element
            snake_case__       :   List[Any]	      =    []
            snake_case__       :   str	      =    []
            snake_case__       :   int	      =    input_ids[:q_len]
            snake_case__       :   List[Any]	      =    range(__SCREAMING_SNAKE_CASE				,      len(__SCREAMING_SNAKE_CASE		)				,      max_length - doc_stride		)
            for i in doc_start_indices:
                  snake_case__       :   Union[str, Any]	      =    i + max_length - q_len
                  snake_case__       :   Optional[int]	      =    input_ids[i:end_index]
                  inputs.append(q_indices + slice		)
                  category.append(answer['category'][0]		)
                  if slice[-1] == tokenizer.sep_token_id:
                        break

            return {
                "example_id": example["id"],
                "input_ids": inputs,
                "labels": {
                    "start_token": [-100] * len(__SCREAMING_SNAKE_CASE		),
                    "end_token": [-100] * len(__SCREAMING_SNAKE_CASE		),
                    "category": category,
                },
            }

      snake_case__       :   List[str]	      =    out['context'].split()
      snake_case__       :   Union[str, Any]	      =    splitted_context[answer['end_token']]
      snake_case__       :   List[str]	      =    len(
          tokenizer(
              ' '.join(splitted_context[: answer['start_token']]		)				,      add_special_tokens=__SCREAMING_SNAKE_CASE				,      ).input_ids		)
      snake_case__       :   Dict	      =    len(
          tokenizer(' '.join(splitted_context[: answer['end_token']]		)				,      add_special_tokens=__SCREAMING_SNAKE_CASE		).input_ids		)

      answer["start_token"] += q_len
      answer["end_token"] += q_len

      # fixing end token
      snake_case__       :   Optional[int]	      =    len(tokenizer(__SCREAMING_SNAKE_CASE				,      add_special_tokens=__SCREAMING_SNAKE_CASE		).input_ids		)
      if num_sub_tokens > 1:
            answer["end_token"] += num_sub_tokens - 1

      snake_case__       :   int	      =    input_ids[answer['start_token'] : answer['end_token'] + 1]  # right & left are inclusive
      snake_case__       :   Union[str, Any]	      =    answer['start_token']
      snake_case__       :   List[Any]	      =    answer['end_token']

      if assertion:
            snake_case__       :   int	      =    tokenizer.decode(__SCREAMING_SNAKE_CASE		)
            if answer["span"] != new:
                  print('ISSUE IN TOKENIZATION'		)
                  print('OLD:'				,      answer['span']		)
                  print('NEW:'				,      __SCREAMING_SNAKE_CASE				,      end='\n\n'		)

      if len(__SCREAMING_SNAKE_CASE		) <= max_length:
            return {
                "example_id": example["id"],
                "input_ids": [input_ids],
                "labels": {
                    "start_token": [answer["start_token"]],
                    "end_token": [answer["end_token"]],
                    "category": answer["category"],
                },
            }

      snake_case__       :   Union[str, Any]	      =    input_ids[:q_len]
      snake_case__       :   Dict	      =    range(__SCREAMING_SNAKE_CASE				,      len(__SCREAMING_SNAKE_CASE		)				,      max_length - doc_stride		)

      snake_case__       :   Any	      =    []
      snake_case__       :   str	      =    []
      snake_case__       :   str	      =    []
      snake_case__       :   Dict	      =    []  # null, yes, no, long, short
      for i in doc_start_indices:
            snake_case__       :   int	      =    i + max_length - q_len
            snake_case__       :   Optional[Any]	      =    input_ids[i:end_index]
            inputs.append(q_indices + slice		)
            assert len(inputs[-1]		) <= max_length, "Issue in truncating length"

            if start_token >= i and end_token <= end_index - 1:
                  snake_case__       :   List[Any]	      =    start_token - i + q_len
                  snake_case__       :   Dict	      =    end_token - i + q_len
                  answers_category.append(answer['category'][0]		)  # ["short"] -> "short"
            else:
                  snake_case__       :   Optional[int]	      =    -100
                  snake_case__       :   List[str]	      =    -100
                  answers_category.append('null'		)
            snake_case__       :   List[Any]	      =    inputs[-1][start_token : end_token + 1]

            answers_start_token.append(__SCREAMING_SNAKE_CASE		)
            answers_end_token.append(__SCREAMING_SNAKE_CASE		)
            if assertion:
                  if new != old and new != [tokenizer.cls_token_id]:
                        print('ISSUE in strided for ID:'				,      example['id']		)
                        print('New:'				,      tokenizer.decode(__SCREAMING_SNAKE_CASE		)		)
                        print('Old:'				,      tokenizer.decode(__SCREAMING_SNAKE_CASE		)				,      end='\n\n'		)
            if slice[-1] == tokenizer.sep_token_id:
                  break

      return {
          "example_id": example["id"],
          "input_ids": inputs,
          "labels": {
              "start_token": answers_start_token,
              "end_token": answers_end_token,
              "category": answers_category,
          },
      }






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE=2048				,      __SCREAMING_SNAKE_CASE=4096				,      __SCREAMING_SNAKE_CASE=False		)    ->   Tuple:
      snake_case__       :   Union[str, Any]	      =    get_strided_contexts_and_ans(
          __SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE				,      doc_stride=__SCREAMING_SNAKE_CASE				,      max_length=__SCREAMING_SNAKE_CASE				,      assertion=__SCREAMING_SNAKE_CASE				,      )

      return example






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE		)    ->   Optional[Any]:
      with jsonlines.open(__SCREAMING_SNAKE_CASE				,      'a'		) as writer:
            for example in tqdm(__SCREAMING_SNAKE_CASE				,      total=len(__SCREAMING_SNAKE_CASE		)				,      desc='Saving samples ... '		):
                  snake_case__       :   Optional[Any]	      =    example['labels']
                  for ids, start, end, cat in zip(
                      example['input_ids']				,      labels['start_token']				,      labels['end_token']				,      labels['category']				,      ):
                        if start == -1 and end == -1:
                              continue  # leave waste samples with no answer
                        if cat == "null" and np.random.rand() < 0.6:
                              continue  # removing 50 % samples
                        writer.write(
                            {
                                'input_ids': ids,
                                'start_token': start,
                                'end_token': end,
                                'category': CATEGORY_MAPPING[cat],
                            }		)


if __name__ == "__main__":
      from datasets import load_dataset

      from transformers import BigBirdTokenizer

      A_			      =		load_dataset("natural_questions")
      A_			      =		BigBirdTokenizer.from_pretrained("google/bigbird-roberta-base")

      A_			      =		data["train" if PROCESS_TRAIN == "true" else "validation"]

      A_			      =		{
          "tokenizer": tokenizer,
          "doc_stride": DOC_STRIDE,
          "max_length": MAX_LENGTH,
          "assertion": False,
      }
      A_			      =		data.map(prepare_inputs, fn_kwargs=fn_kwargs)
      A_			      =		data.remove_columns(["annotations", "document", "id", "question"])
      print(data)

      np.random.seed(SEED)
      A_			      =		"nq-training.jsonl" if PROCESS_TRAIN == "true" else "nq-validation.jsonl"
      save_to_disk(data, file_name=cache_file_name)






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






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE		)    ->   Optional[int]:
      snake_case__       :   Tuple	      =    botoa.client('iam'		)
      return iam_client.get_role(RoleName=__SCREAMING_SNAKE_CASE		)["Role"]["Arn"]






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

            snake_case__       :   int	      =    _ask_field('AWS Secret Access Key: '		)
            snake_case__       :   Optional[int]	      =    aws_secret_access_key

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

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

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

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

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

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

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

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

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