




'''simple docstring'''







import copy

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


lowerCAmelCase_    	=							logging.get_logger(__name__)

lowerCAmelCase_    	=							{}

class   _snake_case( UpperCAmelCase			):
 __snake_case:       Dict									=				'''fsmt_decoder'''






 def __init__(self					:     Tuple						,		a					:     Optional[int]=0						,		a					:     List[Any]=0						)					->      int:






    """simple docstring"""


    super().__init__()
    A__         =    vocab_size
    A__         =    bos_token_id




class   _snake_case( UpperCAmelCase			):
 __snake_case:       str									=				'''fsmt'''
 __snake_case:       Union[str, Any]									=				{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}






 def __init__(self					:     Optional[int]						,		a					:     Any=["en", "de"]						,		a					:     Any=4_20_24						,		a					:     Union[str, Any]=4_20_24						,		a					:     Optional[int]="relu"						,		a					:     str=10_24						,		a					:     Tuple=2_00						,		a					:     Optional[int]=10_24						,		a					:     Union[str, Any]=40_96						,		a					:     int=12						,		a					:     Tuple=16						,		a					:     int=0.0						,		a					:     str=40_96						,		a					:     Optional[Any]=12						,		a					:     Union[str, Any]=16						,		a					:     List[Any]=0.0						,		a					:     int=0.0						,		a					:     str=0.1						,		a					:     Union[str, Any]=0.0						,		a					:     List[Any]=0.02						,		a					:     List[str]=2						,		a					:     str=True						,		a					:     Tuple=True						,		a					:     Union[str, Any]=False						,		a					:     str=5						,		a					:     List[str]=1.0						,		a					:     Dict=False						,		a					:     Optional[int]=True						,		a					:     List[str]=1						,		a					:     Tuple=0						,		a					:     Union[str, Any]=2						,		a					:     List[str]=2						,		**a					:     Any						,		)					->      Optional[Any]:






    """simple docstring"""


    A__         =    langs
    A__         =    src_vocab_size
    A__         =    tgt_vocab_size
    A__         =    d_model  # encoder_embed_dim and decoder_embed_dim

    A__         =    encoder_ffn_dim
    A__         =    A__         =    encoder_layers
    A__         =    encoder_attention_heads
    A__         =    encoder_layerdrop
    A__         =    decoder_layerdrop
    A__         =    decoder_ffn_dim
    A__         =    decoder_layers
    A__         =    decoder_attention_heads
    A__         =    max_position_embeddings
    A__         =    init_std  # Normal(0, this parameter)
    A__         =    activation_function

    A__         =    DecoderConfig(vocab_size=a						,		bos_token_id=a						)
    if "decoder" in common_kwargs:
       del common_kwargs["decoder"]

    A__         =    scale_embedding  # scale factor will be sqrt(d_model) if True

    # 3 Types of Dropout
    A__         =    attention_dropout
    A__         =    activation_dropout
    A__         =    dropout

    A__         =    use_cache
    super().__init__(
        pad_token_id=a						,		bos_token_id=a						,		eos_token_id=a						,		decoder_start_token_id=a						,		is_encoder_decoder=a						,		tie_word_embeddings=a						,		forced_eos_token_id=a						,		max_length=a						,		num_beams=a						,		length_penalty=a						,		early_stopping=a						,		**a						,		)






 def 	_UpperCamelCase   (self					:     int						)					->      Optional[Any]:






    """simple docstring"""


    A__         =    copy.deepcopy(self.__dict__						)
    A__         =    self.decoder.to_dict()
    A__         =    self.__class__.model_type
    return output








'''simple docstring'''







import warnings
from dataclasses import dataclass, field
from typing import Optional, Tuple

from .training_args import TrainingArguments
from .utils import cached_property, is_tf_available, logging, requires_backends


lowerCAmelCase_    	=							logging.get_logger(__name__)

if is_tf_available():
    import tensorflow as tf

@dataclass
class   _snake_case( UpperCAmelCase			):
 __snake_case:       Optional[Any]									=				'''tf'''
 __snake_case:       Optional[str]									=				field(
     default=UpperCAmelCase					,   metadata={'''help''': '''Name of TPU'''}					,   )

 __snake_case:       Optional[str]									=				field(
     default=UpperCAmelCase					,   metadata={'''help''': '''Zone of TPU'''}					,   )

 __snake_case:       Optional[str]									=				field(
     default=UpperCAmelCase					,   metadata={'''help''': '''Name of Cloud TPU-enabled project'''}					,   )

 __snake_case:       float									=				field(
     default=1.0					,   metadata={'''help''': '''Power for the Polynomial decay LR scheduler.'''}					,   )

 __snake_case:       bool									=				field(default=UpperCAmelCase					,   metadata={'''help''': '''Whether to activate the XLA compilation or not'''}			)






 @cached_property
 def 	_UpperCamelCase   (self					:     Tuple						)					->      Tuple["tf.distribute.Strategy", int]:






    """simple docstring"""


    requires_backends(self						,		['tf']						)
    logger.info('Tensorflow: setting up strategy'						)

    A__         =    tf.config.list_physical_devices('GPU'						)

    # Set to float16 at first
    if self.fpaa:
       tf.keras.mixed_precision.set_global_policy('mixed_float16'						)

    if self.no_cuda:
       A__         =    tf.distribute.OneDeviceStrategy(device='/cpu:0'						)
    else:
       try:
          if self.tpu_name:
             A__         =    tf.distribute.cluster_resolver.TPUClusterResolver(
                 self.tpu_name						,		zone=self.tpu_zone						,		project=self.gcp_project						)
          else:
             A__         =    tf.distribute.cluster_resolver.TPUClusterResolver()
       except ValueError:
          if self.tpu_name:
             raise RuntimeError(f"""Couldn't connect to TPU {self.tpu_name}!"""						)
          else:
             A__         =    None

       if tpu:
          # Set to bfloat16 in case of TPU
          if self.fpaa:
             tf.keras.mixed_precision.set_global_policy('mixed_bfloat16'						)

          tf.config.experimental_connect_to_cluster(a						)
          tf.tpu.experimental.initialize_tpu_system(a						)

          A__         =    tf.distribute.TPUStrategy(a						)

       elif len(a						) == 0:
          A__         =    tf.distribute.OneDeviceStrategy(device='/cpu:0'						)
       elif len(a						) == 1:
          A__         =    tf.distribute.OneDeviceStrategy(device='/gpu:0'						)
       elif len(a						) > 1:
          # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
          A__         =    tf.distribute.MirroredStrategy()
       else:
          raise ValueError('Cannot find the proper strategy, please check your environment properties.'						)

    return strategy






 @property
 def 	_UpperCamelCase   (self					:     List[Any]						)					->      "tf.distribute.Strategy":






    """simple docstring"""


    requires_backends(self						,		['tf']						)
    return self._setup_strategy






 @property
 def 	_UpperCamelCase   (self					:     Tuple						)					->      int:






    """simple docstring"""


    requires_backends(self						,		['tf']						)
    return self._setup_strategy.num_replicas_in_sync






 @property
 def 	_UpperCamelCase   (self					:     Optional[Any]						)					->      int:






    """simple docstring"""


    return False  # TF Logging is handled by Keras not the Trainer






 @property
 def 	_UpperCamelCase   (self					:     Union[str, Any]						)					->      int:






    """simple docstring"""


    if self.per_gpu_train_batch_size:
       logger.warning(
           'Using deprecated `--per_gpu_train_batch_size` argument which will be removed in a future '
           'version. Using `--per_device_train_batch_size` is preferred.'						)
    A__         =    self.per_gpu_train_batch_size or self.per_device_train_batch_size
    return per_device_batch_size * self.n_replicas






 @property
 def 	_UpperCamelCase   (self					:     Optional[int]						)					->      int:






    """simple docstring"""


    if self.per_gpu_eval_batch_size:
       logger.warning(
           'Using deprecated `--per_gpu_eval_batch_size` argument which will be removed in a future '
           'version. Using `--per_device_eval_batch_size` is preferred.'						)
    A__         =    self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
    return per_device_batch_size * self.n_replicas






 @property
 def 	_UpperCamelCase   (self					:     Optional[Any]						)					->      int:






    """simple docstring"""


    requires_backends(self						,		['tf']						)
    warnings.warn(
        'The n_gpu argument is deprecated and will be removed in a future version, use n_replicas instead.'						,		a						,		)
    return self._setup_strategy.num_replicas_in_sync


