






from __future__ import annotations

import unittest

from transformers import LEDConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
   import tensorflow as tf

   from transformers import TFLEDForConditionalGeneration, TFLEDModel


@require_tf
class  SCREAMING_SNAKE_CASE			:
     '''simple docstring'''


     UpperCamelCase_							:		Optional[Any]			=	LEDConfig
     UpperCamelCase_							:		int			=	{}
     UpperCamelCase_							:		Union[str, Any]			=	'''gelu'''


     def __init__(				self       :	Optional[int]					, UpperCAmelCase_       :	Optional[Any]					, UpperCAmelCase_       :	int=13					, UpperCAmelCase_       :	Optional[int]=7					, UpperCAmelCase_       :	str=True					, UpperCAmelCase_       :	Dict=False					, UpperCAmelCase_       :	List[str]=99					, UpperCAmelCase_       :	Dict=32					, UpperCAmelCase_       :	Union[str, Any]=2					, UpperCAmelCase_       :	int=4					, UpperCAmelCase_       :	List[str]=37					, UpperCAmelCase_       :	List[str]=0.1					, UpperCAmelCase_       :	Any=0.1					, UpperCAmelCase_       :	Union[str, Any]=20					, UpperCAmelCase_       :	List[str]=2					, UpperCAmelCase_       :	Tuple=1					, UpperCAmelCase_       :	Union[str, Any]=0					, UpperCAmelCase_       :	Tuple=4					, ):
       SCREAMING_SNAKE_CASE       :      List[str]							=    parent
       SCREAMING_SNAKE_CASE       :      Dict							=    batch_size
       SCREAMING_SNAKE_CASE       :      List[str]							=    seq_length
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    is_training
       SCREAMING_SNAKE_CASE       :      Dict							=    use_labels
       SCREAMING_SNAKE_CASE       :      List[Any]							=    vocab_size
       SCREAMING_SNAKE_CASE       :      Tuple							=    hidden_size
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    num_hidden_layers
       SCREAMING_SNAKE_CASE       :      Any							=    num_attention_heads
       SCREAMING_SNAKE_CASE       :      Any							=    intermediate_size

       SCREAMING_SNAKE_CASE       :      Dict							=    hidden_dropout_prob
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    max_position_embeddings
       SCREAMING_SNAKE_CASE       :      str							=    eos_token_id
       SCREAMING_SNAKE_CASE       :      List[Any]							=    pad_token_id
       SCREAMING_SNAKE_CASE       :      List[str]							=    bos_token_id
       SCREAMING_SNAKE_CASE       :      Dict							=    attention_window

       # `ModelTesterMixin.test_attention_outputs` is expecting attention tensors to be of size
       # [num_attention_heads, encoder_seq_length, encoder_key_length], but TFLongformerSelfAttention
       # returns attention of shape [num_attention_heads, encoder_seq_length, self.attention_window + 1]
       # because its local attention only attends to `self.attention_window` and one before and one after
       SCREAMING_SNAKE_CASE       :      Any							=    self.attention_window + 2

       # because of padding `encoder_seq_length`, is different from `seq_length`. Relevant for
       # the `test_attention_outputs` and `test_hidden_states_output` tests
       SCREAMING_SNAKE_CASE       :      str							=    (
           self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window
       )


     def 				_A       (				self       :	Union[str, Any]      ):
       SCREAMING_SNAKE_CASE       :      Tuple							=    ids_tensor([self.batch_size, self.seq_length - 1]					, self.vocab_size      )
       SCREAMING_SNAKE_CASE       :      int							=    tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size      )					, 1      )
       SCREAMING_SNAKE_CASE       :      int							=    tf.concat([input_ids, eos_tensor]					, axis=1      )

       SCREAMING_SNAKE_CASE       :      List[str]							=    ids_tensor([self.batch_size, self.seq_length]					, self.vocab_size      )

       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    self.config_cls(
           vocab_size=self.vocab_size					, d_model=self.hidden_size					, encoder_layers=self.num_hidden_layers					, decoder_layers=self.num_hidden_layers					, encoder_attention_heads=self.num_attention_heads					, decoder_attention_heads=self.num_attention_heads					, encoder_ffn_dim=self.intermediate_size					, decoder_ffn_dim=self.intermediate_size					, dropout=self.hidden_dropout_prob					, attention_dropout=self.attention_probs_dropout_prob					, max_position_embeddings=self.max_position_embeddings					, eos_token_ids=[2]					, bos_token_id=self.bos_token_id					, pad_token_id=self.pad_token_id					, decoder_start_token_id=self.pad_token_id					, attention_window=self.attention_window					, **self.config_updates					, )
       SCREAMING_SNAKE_CASE       :      List[str]							=    prepare_led_inputs_dict(UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    tf.concat(
           [tf.zeros_like(UpperCAmelCase_      )[:, :-1], tf.ones_like(UpperCAmelCase_      )[:, -1:]]					, axis=-1					, )
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    global_attention_mask
       return config, inputs_dict






     def 				_A       (				self       :	List[str]					, UpperCAmelCase_       :	str					, UpperCAmelCase_       :	List[Any]      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    TFLEDModel(config=UpperCAmelCase_      ).get_decoder()
       SCREAMING_SNAKE_CASE       :      Dict							=    inputs_dict["input_ids"]

       SCREAMING_SNAKE_CASE       :      Tuple							=    input_ids[:1, :]
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    inputs_dict["attention_mask"][:1, :]
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    1

       # first forward pass
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    model(UpperCAmelCase_					, attention_mask=UpperCAmelCase_					, use_cache=UpperCAmelCase_      )

       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Optional[int]							=    outputs.to_tuple()

       # create hypothetical next token and extent to next_input_ids
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    ids_tensor((self.batch_size, 3)					, config.vocab_size      )
       SCREAMING_SNAKE_CASE       :      List[str]							=    tf.cast(ids_tensor((self.batch_size, 3)					, 2      )					, tf.inta      )

       # append to next input_ids and
       SCREAMING_SNAKE_CASE       :      List[str]							=    tf.concat([input_ids, next_tokens]					, axis=-1      )
       SCREAMING_SNAKE_CASE       :      Tuple							=    tf.concat([attention_mask, next_attn_mask]					, axis=-1      )

       SCREAMING_SNAKE_CASE       :      Optional[int]							=    model(UpperCAmelCase_					, attention_mask=UpperCAmelCase_      )[0]
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    model(UpperCAmelCase_					, attention_mask=UpperCAmelCase_					, past_key_values=UpperCAmelCase_      )[0]

       self.parent.assertEqual(next_tokens.shape[1]					, output_from_past.shape[1]      )

       # select random slice
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    int(ids_tensor((1,)					, output_from_past.shape[-1]      )      )
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    output_from_no_past[:, -3:, random_slice_idx]
       SCREAMING_SNAKE_CASE       :      List[Any]							=    output_from_past[:, :, random_slice_idx]

       # test that outputs are equal for slice
       tf.debugging.assert_near(UpperCAmelCase_					, UpperCAmelCase_					, rtol=1E-3      )





def   lowerCamelCase__			(     lowercase						,     lowercase						,     lowercase						,     lowercase=None						,     lowercase=None						,     lowercase=None						,     lowercase=None						,     ):

  """simple docstring"""






  if attention_mask is None:
    SCREAMING_SNAKE_CASE       :      Dict							=    tf.cast(tf.math.not_equal(lowercase						,     config.pad_token_id				)						,     tf.inta				)
  if decoder_attention_mask is None:
    SCREAMING_SNAKE_CASE       :      Dict							=    tf.concat(
        [
            tf.ones(decoder_input_ids[:, :1].shape						,     dtype=tf.inta				),
            tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]						,     config.pad_token_id				)						,     tf.inta				),
        ]						,     axis=-1						,     )
  if head_mask is None:
    SCREAMING_SNAKE_CASE       :      Any							=    tf.ones((config.encoder_layers, config.encoder_attention_heads)				)
  if decoder_head_mask is None:
    SCREAMING_SNAKE_CASE       :      Optional[int]							=    tf.ones((config.decoder_layers, config.decoder_attention_heads)				)
  return {
      "input_ids": input_ids,
      "attention_mask": attention_mask,
      "decoder_input_ids": decoder_input_ids,
      "decoder_attention_mask": decoder_attention_mask,
      "head_mask": head_mask,
      "decoder_head_mask": decoder_head_mask,
  }


@require_tf
class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase      ,		lowerCAmelCase      ,		unittest.TestCase					):
     '''simple docstring'''


     UpperCamelCase_							:		Optional[Any]			=	(TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
     UpperCamelCase_							:		Optional[Any]			=	(TFLEDForConditionalGeneration,) if is_tf_available() else ()
     UpperCamelCase_							:		str			=	(
         {
             '''conversational''': TFLEDForConditionalGeneration,
             '''feature-extraction''': TFLEDModel,
             '''summarization''': TFLEDForConditionalGeneration,
             '''text2text-generation''': TFLEDForConditionalGeneration,
             '''translation''': TFLEDForConditionalGeneration,
         }
         if is_tf_available()
         else {}
     )
     UpperCamelCase_							:		int			=	True
     UpperCamelCase_							:		str			=	False
     UpperCamelCase_							:		Tuple			=	False
     UpperCamelCase_							:		str			=	False


     def 				_A       (				self       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      List[str]							=    TFLEDModelTester(self      )
       SCREAMING_SNAKE_CASE       :      List[str]							=    ConfigTester(self					, config_class=UpperCAmelCase_      )


     def 				_A       (				self       :	List[Any]      ):
       self.config_tester.run_common_tests()


     def 				_A       (				self       :	Any      ):
       SCREAMING_SNAKE_CASE       :      str							=    self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.check_decoder_model_past_large_inputs(*UpperCAmelCase_      )


     def 				_A       (				self       :	Union[str, Any]      ):
       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    tf.zeros_like(inputs_dict["attention_mask"]      )
       SCREAMING_SNAKE_CASE       :      str							=    2
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    tf.where(
           tf.range(self.model_tester.seq_length      )[None, :] < num_global_attn_indices					, 1					, inputs_dict["global_attention_mask"]					, )

       SCREAMING_SNAKE_CASE       :      List[Any]							=    True
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    self.model_tester.seq_length
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    self.model_tester.encoder_seq_length

       def check_decoder_attentions_output(UpperCAmelCase_       :	str      ):
         SCREAMING_SNAKE_CASE       :      Dict							=    outputs.decoder_attentions
         self.assertEqual(len(UpperCAmelCase_      )					, self.model_tester.num_hidden_layers      )
         self.assertListEqual(
             list(decoder_attentions[0].shape[-3:]      )					, [self.model_tester.num_attention_heads, seq_length, seq_length]					, )

       def check_encoder_attentions_output(UpperCAmelCase_       :	Optional[int]      ):
         SCREAMING_SNAKE_CASE       :      Optional[int]							=    [t.numpy() for t in outputs.encoder_attentions]
         SCREAMING_SNAKE_CASE       :      Optional[Any]							=    [t.numpy() for t in outputs.encoder_global_attentions]
         self.assertEqual(len(UpperCAmelCase_      )					, self.model_tester.num_hidden_layers      )
         self.assertEqual(len(UpperCAmelCase_      )					, self.model_tester.num_hidden_layers      )
         self.assertListEqual(
             list(attentions[0].shape[-3:]      )					, [self.model_tester.num_attention_heads, seq_length, seq_length]					, )
         self.assertListEqual(
             list(global_attentions[0].shape[-3:]      )					, [self.model_tester.num_attention_heads, encoder_seq_length, num_global_attn_indices]					, )

       for model_class in self.all_model_classes:
         SCREAMING_SNAKE_CASE       :      Tuple							=    True
         SCREAMING_SNAKE_CASE       :      List[Any]							=    False
         SCREAMING_SNAKE_CASE       :      Dict							=    False
         SCREAMING_SNAKE_CASE       :      Any							=    model_class(UpperCAmelCase_      )
         SCREAMING_SNAKE_CASE       :      Any							=    model(self._prepare_for_class(UpperCAmelCase_					, UpperCAmelCase_      )      )
         SCREAMING_SNAKE_CASE       :      List[str]							=    len(UpperCAmelCase_      )
         self.assertEqual(config.output_hidden_states					, UpperCAmelCase_      )
         check_encoder_attentions_output(UpperCAmelCase_      )

         if self.is_encoder_decoder:
           SCREAMING_SNAKE_CASE       :      Optional[int]							=    model_class(UpperCAmelCase_      )
           SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    model(self._prepare_for_class(UpperCAmelCase_					, UpperCAmelCase_      )      )
           self.assertEqual(config.output_hidden_states					, UpperCAmelCase_      )
           check_decoder_attentions_output(UpperCAmelCase_      )

         # Check that output attentions can also be changed via the config
         del inputs_dict["output_attentions"]
         SCREAMING_SNAKE_CASE       :      int							=    True
         SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    model_class(UpperCAmelCase_      )
         SCREAMING_SNAKE_CASE       :      List[Any]							=    model(self._prepare_for_class(UpperCAmelCase_					, UpperCAmelCase_      )      )
         self.assertEqual(config.output_hidden_states					, UpperCAmelCase_      )
         check_encoder_attentions_output(UpperCAmelCase_      )

         # Check attention is always last and order is fine
         SCREAMING_SNAKE_CASE       :      List[str]							=    True
         SCREAMING_SNAKE_CASE       :      Optional[Any]							=    True
         SCREAMING_SNAKE_CASE       :      Optional[Any]							=    model_class(UpperCAmelCase_      )
         SCREAMING_SNAKE_CASE       :      Dict							=    model(self._prepare_for_class(UpperCAmelCase_					, UpperCAmelCase_      )      )

         self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)					, len(UpperCAmelCase_      )      )
         self.assertEqual(model.config.output_hidden_states					, UpperCAmelCase_      )
         check_encoder_attentions_output(UpperCAmelCase_      )


     @unittest.skip("LED keeps using potentially symbolic tensors in conditionals and breaks tracing."      )
     def 				_A       (				self       :	int      ):
       pass






     def 				_A       (				self       :	str      ):
       # TODO: Head-masking not yet implement
       pass





def   lowerCamelCase__			(     lowercase				):

  """simple docstring"""






  return tf.constant(lowercase						,     dtype=tf.intaa				)


snake_case    				=		1e-4


@slow
@require_tf
class  SCREAMING_SNAKE_CASE			(			unittest.TestCase					):
     '''simple docstring'''


     def 				_A       (				self       :	Optional[Any]      ):
       SCREAMING_SNAKE_CASE       :      str							=    TFLEDForConditionalGeneration.from_pretrained("allenai/led-base-16384"      ).led

       # change to intended input here
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    _long_tensor([512 * [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69]]      )
       SCREAMING_SNAKE_CASE       :      int							=    _long_tensor([128 * [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69]]      )
       SCREAMING_SNAKE_CASE       :      List[Any]							=    prepare_led_inputs_dict(model.config					, UpperCAmelCase_					, UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      Tuple							=    model(**UpperCAmelCase_      )[0]
       SCREAMING_SNAKE_CASE       :      int							=    (1, 1024, 768)
       self.assertEqual(output.shape					, UpperCAmelCase_      )
       # change to expected output here
       SCREAMING_SNAKE_CASE       :      List[str]							=    tf.convert_to_tensor(
           [[2.3_050, 2.8_279, 0.6_531], [-1.8_457, -0.1_455, -3.5_661], [-1.0_186, 0.4_586, -2.2_043]]					, )
       tf.debugging.assert_near(output[:, :3, :3]					, UpperCAmelCase_					, atol=1E-3      )






     def 				_A       (				self       :	List[str]      ):
       SCREAMING_SNAKE_CASE       :      str							=    TFLEDForConditionalGeneration.from_pretrained("allenai/led-base-16384"      )

       # change to intended input here
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    _long_tensor([512 * [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69]]      )
       SCREAMING_SNAKE_CASE       :      str							=    _long_tensor([128 * [0, 3_1414, 232, 328, 740, 1140, 1_2695, 69]]      )
       SCREAMING_SNAKE_CASE       :      Tuple							=    prepare_led_inputs_dict(model.config					, UpperCAmelCase_					, UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    model(**UpperCAmelCase_      )[0]
       SCREAMING_SNAKE_CASE       :      Dict							=    (1, 1024, model.config.vocab_size)
       self.assertEqual(output.shape					, UpperCAmelCase_      )
       # change to expected output here
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    tf.convert_to_tensor(
           [[33.6_507, 6.4_572, 16.8_089], [5.8_739, -2.4_238, 11.2_902], [-3.2_139, -4.3_149, 4.2_783]]					, )
       tf.debugging.assert_near(output[:, :3, :3]					, UpperCAmelCase_					, atol=1E-3					, rtol=1E-3      )














# 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.

from pathlib import Path

import torch

from ...utils import is_npu_available, is_xpu_available
from .config_args import ClusterConfig, default_json_config_file
from .config_utils import SubcommandHelpFormatter


snake_case    				=		"""Create a default config file for Accelerate with only a few flags set."""


def   lowerCamelCase__			(     lowercase="no"						,     lowercase = default_json_config_file						,     lowercase = False				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      Tuple							=    Path(lowercase				)
  path.parent.mkdir(parents=lowercase						,     exist_ok=lowercase				)
  if path.exists():
    print(
        F'''Configuration already exists at {save_location}, will not override. Run `accelerate config` manually or pass a different `save_location`.'''				)
    return False
  SCREAMING_SNAKE_CASE       :      int							=    mixed_precision.lower()
  if mixed_precision not in ["no", "fp16", "bf16", "fp8"]:
    raise ValueError(
        F'''`mixed_precision` should be one of \'no\', \'fp16\', \'bf16\', or \'fp8\'. Received {mixed_precision}'''				)
  SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    {
      "compute_environment": "LOCAL_MACHINE",
      "mixed_precision": mixed_precision,
  }
  if torch.cuda.is_available():
    SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    torch.cuda.device_count()
    SCREAMING_SNAKE_CASE       :      int							=    num_gpus
    SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    False
    if num_gpus > 1:
      SCREAMING_SNAKE_CASE       :      Tuple							=    "MULTI_GPU"
    else:
      SCREAMING_SNAKE_CASE       :      Optional[Any]							=    "NO"
  elif is_xpu_available() and use_xpu:
    SCREAMING_SNAKE_CASE       :      List[str]							=    torch.xpu.device_count()
    SCREAMING_SNAKE_CASE       :      str							=    num_xpus
    SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    False
    if num_xpus > 1:
      SCREAMING_SNAKE_CASE       :      Any							=    "MULTI_XPU"
    else:
      SCREAMING_SNAKE_CASE       :      str							=    "NO"
  elif is_npu_available():
    SCREAMING_SNAKE_CASE       :      List[Any]							=    torch.npu.device_count()
    SCREAMING_SNAKE_CASE       :      Optional[Any]							=    num_npus
    SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    False
    if num_npus > 1:
      SCREAMING_SNAKE_CASE       :      str							=    "MULTI_NPU"
    else:
      SCREAMING_SNAKE_CASE       :      int							=    "NO"
  else:
    SCREAMING_SNAKE_CASE       :      Dict							=    0
    SCREAMING_SNAKE_CASE       :      List[Any]							=    True
    SCREAMING_SNAKE_CASE       :      Dict							=    1
    SCREAMING_SNAKE_CASE       :      int							=    "NO"
  SCREAMING_SNAKE_CASE       :      Dict							=    ClusterConfig(**lowercase				)
  config.to_json_file(lowercase				)
  return path


def   lowerCamelCase__			(     lowercase						,     lowercase				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      Dict							=    parser.add_parser("default"						,     parents=lowercase						,     help=lowercase						,     formatter_class=lowercase				)
  parser.add_argument(
      "--config_file"						,     default=lowercase						,     help=(
          "The path to use to store the config file. Will default to a file named default_config.yaml in the cache "
          "location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have "
          "such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed "
          "with 'huggingface'."
      )						,     dest="save_location"						,     )

  parser.add_argument(
      "--mixed_precision"						,     choices=["no", "fp16", "bf16"]						,     type=lowercase						,     help="Whether or not to use mixed precision training. "
      "Choose between FP16 and BF16 (bfloat16) training. "
      "BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later."						,     default="no"						,     )
  parser.set_defaults(func=lowercase				)
  return parser


def   lowerCamelCase__			(     lowercase				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      Optional[int]							=    write_basic_config(args.mixed_precision						,     args.save_location				)
  if config_file:
    print(F'''accelerate configuration saved at {config_file}'''				)






