multilinguality_megatron/megatron/arguments.py

# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.

"""Megatron arguments."""

import argparse
import os

import torch

import megatron
from megatron.metrics import METRICS
from megatron.model.enums import PositionEmbeddingType


def build_base_parser():
    parser = argparse.ArgumentParser(description='Megatron-LM Arguments',
                                     allow_abbrev=False)
    # Standard arguments.
    parser = _add_network_size_args(parser)
    parser = _add_regularization_args(parser)
    parser = _add_training_args(parser)
    parser = _add_initialization_args(parser)
    parser = _add_learning_rate_args(parser)
    parser = _add_checkpointing_args(parser)
    parser = _add_mixed_precision_args(parser)
    parser = _add_distributed_args(parser)
    parser = _add_validation_args(parser)
    parser = _add_data_args(parser)
    parser = _add_autoresume_args(parser)
    parser = _add_biencoder_args(parser)
    parser = _add_vision_args(parser)
    parser = _add_logging_args(parser)
    parser = _add_inference_args(parser)
    parser = _add_transformer_engine_args(parser)
    return parser


def parse_args(extra_args_provider=None):
    """Parse all arguments."""
    parser = build_base_parser()
    # Custom arguments.
    if extra_args_provider is not None:
        parser = extra_args_provider(parser)

    args = parser.parse_args()

    # Args from environment
    args.rank = int(os.getenv('RANK', '0'))
    args.world_size = int(os.getenv("WORLD_SIZE", '1'))
    return args


def validate_args(args, defaults={}):
    # Tensor model parallel size.
    args.tensor_model_parallel_size = min(
        args.tensor_model_parallel_size, args.world_size)
    assert args.world_size % args.tensor_model_parallel_size == 0, 'world size'\
        ' ({}) is not divisible by tensor model parallel size ({})'.format(
            args.world_size, args.tensor_model_parallel_size)
    # Pipeline model parallel size.
    args.pipeline_model_parallel_size = min(
        args.pipeline_model_parallel_size,
        (args.world_size // args.tensor_model_parallel_size))
    args.transformer_pipeline_model_parallel_size = (
        args.pipeline_model_parallel_size - 1
        if args.standalone_embedding_stage else
        args.pipeline_model_parallel_size
    )
    # Checks.
    model_parallel_size = args.pipeline_model_parallel_size * \
                          args.tensor_model_parallel_size
    assert args.world_size % model_parallel_size == 0, 'world size is not'\
        ' divisible by tensor parallel size ({}) times pipeline parallel ' \
        'size ({})'.format(args.world_size, args.tensor_model_parallel_size,
                           args.pipeline_model_parallel_size)
    args.data_parallel_size = args.world_size // model_parallel_size
    if args.rank == 0:
        print('using world size: {}, data-parallel-size: {}, '
              'tensor-model-parallel size: {}, '
              'pipeline-model-parallel size: {} '.format(
                  args.world_size, args.data_parallel_size,
                  args.tensor_model_parallel_size,
                  args.pipeline_model_parallel_size), flush=True)
    if args.pipeline_model_parallel_size > 1:
        if args.pipeline_model_parallel_split_rank is not None:
            assert args.pipeline_model_parallel_split_rank < \
                    args.pipeline_model_parallel_size, 'split rank needs'\
                    ' to be less than pipeline model parallel size ({})'.format(
                            args.pipeline_model_parallel_size)

    if args.recompute_activations:
        args.recompute_granularity = 'selective'
    del args.recompute_activations
    if args.metrics == ["all"]:
        args.metrics = list(METRICS)


    # Set input defaults.
    for key in defaults:
        # For default to be valid, it should not be provided in the
        # arguments that are passed to the program. We check this by
        # ensuring the arg is set to None.
        if getattr(args, key) is not None:
            if args.rank == 0:
                print('WARNING: overriding default arguments for {key}:{v} \
                       with {key}:{v2}'.format(key=key, v=defaults[key],
                                               v2=getattr(args, key)),
                                               flush=True)
        else:
            setattr(args, key, defaults[key])

    # Batch size.
    assert args.micro_batch_size is not None
    assert args.micro_batch_size > 0
    if args.global_batch_size is None:
        args.global_batch_size = args.micro_batch_size * args.data_parallel_size
        if args.rank == 0:
            print('setting global batch size to {}'.format(
                args.global_batch_size), flush=True)
    assert args.global_batch_size > 0
    if args.num_layers_per_virtual_pipeline_stage is not None:
        assert args.pipeline_model_parallel_size > 2, \
            'pipeline-model-parallel size should be greater than 2 with ' \
            'interleaved schedule'
        assert args.num_layers % args.num_layers_per_virtual_pipeline_stage == 0, \
            'number of layers is not divisible by number of layers per virtual ' \
            'pipeline stage'
        args.virtual_pipeline_model_parallel_size = \
            (args.num_layers // args.transformer_pipeline_model_parallel_size) // \
            args.num_layers_per_virtual_pipeline_stage
    else:
        args.virtual_pipeline_model_parallel_size = None

    # Parameters dtype.
    args.params_dtype = torch.float
    if args.fp16:
        assert not args.bf16
        args.params_dtype = torch.half
    if args.bf16:
        assert not args.fp16
        args.params_dtype = torch.bfloat16
        # bfloat16 requires gradient accumulation and all-reduce to
        # be done in fp32.
        if not args.accumulate_allreduce_grads_in_fp32:
            args.accumulate_allreduce_grads_in_fp32 = True
            if args.rank == 0:
                print('accumulate and all-reduce gradients in fp32 for '
                      'bfloat16 data type.', flush=True)

    if args.rank == 0:
        print('using {} for parameters ...'.format(args.params_dtype),
              flush=True)

    # If we do accumulation and all-reduces in fp32, we need to have local DDP
    # and we should make sure use-contiguous-buffers-in-local-ddp is not off.
    if args.accumulate_allreduce_grads_in_fp32:
        assert args.DDP_impl == 'local'
        assert args.use_contiguous_buffers_in_local_ddp

    # If we use the distributed optimizer, we need to have local DDP
    # and we should make sure use-contiguous-buffers-in-local-ddp is on.
    if args.use_distributed_optimizer:
        assert args.DDP_impl == 'local'
        assert args.use_contiguous_buffers_in_local_ddp

    # For torch DDP, we do not use contiguous buffer
    if args.DDP_impl == 'torch':
        args.use_contiguous_buffers_in_local_ddp = False

    if args.dataloader_type is None:
        args.dataloader_type = 'single'

    # Consumed tokens.
    args.consumed_train_samples = 0
    args.consumed_valid_samples = 0

    # Support for variable sequence lengths across batches/microbatches.
    # set it if the dataloader supports generation of variable sequence lengths
    # across batches/microbatches. Due to additional communication overhead
    # during pipeline parallelism, it should not be set if sequence length
    # is constant during training.
    if args.variable_seq_lengths is None:
        args.variable_seq_lengths = False

    # Iteration-based training.
    if args.train_iters:
        # If we use iteration-based training, make sure the
        # sample-based options are off.
        assert args.train_samples is None, \
            'expected iteration-based training'
        assert args.lr_decay_samples is None, \
            'expected iteration-based learning rate decay'
        assert args.lr_warmup_samples == 0, \
            'expected iteration-based learning rate warmup'
        assert args.rampup_batch_size is None, \
            'expected no batch-size rampup for iteration-based training'
        if args.lr_warmup_fraction is not None:
            assert args.lr_warmup_iters == 0, \
                'can only specify one of lr_warmup_fraction and lr_warmup_iters'

    # Sample-based training.
    if args.train_samples:
        # If we use sample-based training, make sure the
        # iteration-based options are off.
        assert args.train_iters is None, \
            'expected sample-based training'
        assert args.lr_decay_iters is None, \
            'expected sample-based learning rate decay'
        assert args.lr_warmup_iters == 0, \
            'expected sample-based learning rate warmup'
        if args.lr_warmup_fraction is not None:
            assert args.lr_warmup_samples == 0, \
                'can only specify one of lr_warmup_fraction ' \
                'and lr_warmup_samples'

    if args.num_layers is not None:
        assert args.encoder_num_layers is None, \
            'cannot have both num_layers and encoder_num_layers specified'
        args.encoder_num_layers = args.num_layers
    else:
        assert args.encoder_num_layers is not None, \
            'either num_layers or encoder_num_layers should be specified'
        args.num_layers = args.encoder_num_layers

    # Check required arguments.
    # required_args = ['num_layers', 'hidden_size', 'num_attention_heads',
    #                  'max_position_embeddings']
    required_args = ['num_layers', 'hidden_size', 'num_attention_heads']
    for req_arg in required_args:
        _check_arg_is_not_none(args, req_arg)

    # Checks.
    if args.ffn_hidden_size is None:
        args.ffn_hidden_size = 4 * args.hidden_size

    if args.kv_channels is None:
        assert args.hidden_size % args.num_attention_heads == 0
        args.kv_channels = args.hidden_size // args.num_attention_heads

    if args.num_attention_heads_kv is None:
        args.num_attention_heads_kv = args.num_attention_heads

    if args.seq_length is not None:
        assert args.encoder_seq_length is None
        args.encoder_seq_length = args.seq_length
    else:
        assert args.encoder_seq_length is not None
        args.seq_length = args.encoder_seq_length

    if not isinstance(args.position_embedding_type, PositionEmbeddingType):
        args.position_embedding_type = PositionEmbeddingType[args.position_embedding_type]
    if args.position_embedding_type in [PositionEmbeddingType.absolute, PositionEmbeddingType.rotary]:
        assert args.max_position_embeddings is not None
        if args.seq_length is not None:
            assert args.max_position_embeddings >= args.seq_length
        if args.decoder_seq_length is not None:
            assert args.max_position_embeddings >= args.decoder_seq_length
        assert args.rope_scaling_factor >= 1, 'rope_scaling_factor must be >= 1'
    else:
        assert args.max_position_embeddings is None

    if args.lr is not None:
        assert args.min_lr <= args.lr
    if args.save is not None:
        assert args.save_interval is not None
    # Mixed precision checks.
    if args.fp16_lm_cross_entropy:
        assert args.fp16, 'lm cross entropy in fp16 only support in fp16 mode.'
    if args.fp32_residual_connection:
        assert args.fp16 or args.bf16, \
            'residual connection in fp32 only supported when using fp16 or bf16.'

    if args.weight_decay_incr_style == 'constant':
        assert args.start_weight_decay is None
        assert args.end_weight_decay is None
        args.start_weight_decay = args.weight_decay
        args.end_weight_decay = args.weight_decay
    else:
        assert args.start_weight_decay is not None
        assert args.end_weight_decay is not None

    TORCH_MAJOR = int(torch.__version__.split('.')[0])
    TORCH_MINOR = int(torch.__version__.split('.')[1])
    # Persistent fused layer norm.
    if TORCH_MAJOR < 1 or (TORCH_MAJOR == 1 and TORCH_MINOR < 11):
        args.no_persist_layer_norm = True
        if args.rank == 0:
            print('Persistent fused layer norm kernel is supported from '
                  'pytorch v1.11 (nvidia pytorch container paired with v1.11). '
                  'Defaulting to no_persist_layer_norm=True')

    # Activation recomputing.
    if args.distribute_saved_activations:
        assert args.tensor_model_parallel_size > 1, 'can distribute ' \
            'recomputed activations only across tensor model ' \
            'parallel groups'
        assert args.recompute_granularity == 'full', \
            'distributed recompute activations is only '\
            'application to full recompute granularity'
        assert args.recompute_method is not None, \
            'for distributed recompute activations to work you '\
            'need to use a recompute method '
        assert TORCH_MAJOR >= 1 and TORCH_MINOR >= 10, \
            'distributed recompute activations are supported for pytorch ' \
            'v1.10 and above (Nvidia Pytorch container >= 21.07). Current ' \
            'pytorch version is v%s.%s.' % (TORCH_MAJOR, TORCH_MINOR)

    # Tranformer-Engine/FP8 related checking
    if args.fp8_e4m3 or args.fp8_hybrid:
        assert args.transformer_impl == 'transformer_engine', \
            'transformer-engine required for fp8 training and inference'

    assert not (args.fp8_e4m3 and args.fp8_hybrid), \
        'cannot train with both fp8 e4m3 and hybrid formatting'

    if args.fp16:
        assert args.transformer_impl == 'local', \
            'transformer-engine not yet approved for fp16 training and inference'

    if args.recompute_granularity == 'selective':
        assert args.recompute_method is None, \
            'recompute method is not yet supported for ' \
            'selective recomputing granularity'

    # Parallel attention.
    if not args.parallel_attn:
        assert not args.parallel_layernorm, "parallel_layernorm only implemented with parallel_attention"

    # disable sequence parallelism when tp=1
    # to avoid change in numerics when
    # sequence_parallelism is enabled.
    if args.tensor_model_parallel_size == 1:
        args.sequence_parallel = False

    # disable async_tensor_model_parallel_allreduce when
    # model parallel memory optimization is enabled
    if args.sequence_parallel:
        args.async_tensor_model_parallel_allreduce = False

    if os.environ.get('CUDA_DEVICE_MAX_CONNECTIONS') and os.environ.get('CUDA_DEVICE_MAX_CONNECTIONS') != "1":
        if args.sequence_parallel:
            raise RuntimeError(
                "Using sequence parallelism requires setting the environment variable "
                "CUDA_DEVICE_MAX_CONNECTIONS to 1")
        if args.async_tensor_model_parallel_allreduce:
            raise RuntimeError(
                "Using async gradient all reduce requires setting the environment "
                "variable CUDA_DEVICE_MAX_CONNECTIONS to 1")
    _print_args(args)
    return args


def _print_args(args):
    """Print arguments."""
    if args.rank == 0:
        print('------------------------ arguments ------------------------',
              flush=True)
        str_list = []
        for arg in vars(args):
            dots = '.' * (48 - len(arg))
            str_list.append('  {} {} {}'.format(arg, dots, getattr(args, arg)))
        for arg in sorted(str_list, key=lambda x: x.lower()):
            print(arg, flush=True)
        print('-------------------- end of arguments ---------------------',
              flush=True)


def _check_arg_is_not_none(args, arg):
    assert getattr(args, arg) is not None, '{} argument is None'.format(arg)


def _add_transformer_engine_args(parser):
    group = parser.add_argument_group(title='Transformer-Engine')
    group.add_argument('--fp8_e4m3', action='store_true',
                        help='E4M3 TransformerLayer', dest='fp8_e4m3')
    group.add_argument('--fp8_hybrid', action='store_true',
                        help='Hybrid FP8 TransformerLayer')
    group.add_argument('--no_fp8_wgrad', action='store_false',
                        help='Execute wgrad in higher precision even for FP8 runs', dest='fp8_wgrad')
    group.add_argument('--fp8_margin', type=int, default=0,
                        help='Scaling margin for fp8', dest='fp8_margin')
    group.add_argument('--fp8_interval', type=int, default=1,
                        help='Scaling update interval for fp8', dest='fp8_interval')
    group.add_argument('--transformer_impl', default='local',
                       choices=['local', 'transformer_engine'],
                       help='Which Transformer implementation to use.')
    group.add_argument('--fp8_amax_history_len', type=int, default=1,
                        help='Number of steps for which amax history is recorded per tensor')
    group.add_argument('--fp8_amax_compute_algo', default='most_recent',
                       choices=['most_recent', 'max'],
                       help='Algorithm for computing amax from history')
    return parser


def _add_inference_args(parser):
    group = parser.add_argument_group(title='inference')
    group.add_argument('--inference_batch_times_seqlen_threshold',
                       type=int, default=512,
                       help='During inference, if batch-size times '
                       'sequence-length is smaller than this threshold '
                       'then we will not use pipelining, otherwise we will.')
    group.add_argument('--max_tokens_to_oom',
                       type=int, default=12000,
                       help='Maximum number of tokens during inference'
                       'tokens here is # in prompt + # to generate'
                       'Allows us to throw an error before OOM crashes server')
    return parser

    
def _add_network_size_args(parser):
    group = parser.add_argument_group(title='network size')
    group.add_argument('--num_layers', type=int, default=None,
                       help='Number of transformer layers.')
    group.add_argument('--encoder_num_layers', type=int, default=None,
                       help='Number of encoder transformer layers.')
    group.add_argument('--decoder_num_layers', type=int, default=None,
                       help='Number of decoder transformer layers.')
    group.add_argument('--hidden_size', type=int, default=None,
                       help='Tansformer hidden size.')
    group.add_argument('--ffn_hidden_size', type=int, default=None,
                       help='Transformer Feed-Forward Network hidden size. '
                       'This is set to 4*hidden_size if not provided')
    group.add_argument('--num_attention_heads', type=int, default=None,
                       help='Number of transformer attention heads.')
    group.add_argument('--num_attention_heads_kv', type=int, default=None,
                       help='Number of transformer attention heads for the keys and values.')
    group.add_argument('--kv_channels', type=int, default=None,
                       help='Projection weights dimension in multi-head '
                       'attention. This is set to '
                       '   args.hidden_size // args.num_attention_heads '
                       'if not provided.')
    group.add_argument('--max_position_embeddings', type=int, default=None,
                       help='Maximum number of position embeddings to use. '
                       'This is the size of position embedding.')
    group.add_argument('--make_vocab_size_divisible_by', type=int, default=128,
                       help='Pad the vocab size to be divisible by this value.'
                       'This is added for computational efficieny reasons.')
    group.add_argument('--layernorm_epsilon', type=float, default=1e-5,
                       help='Layer norm epsilon.')
    group.add_argument('--apply_residual_connection_post_layernorm',
                       action='store_true',
                       help='If set, use original BERT residual connection '
                       'ordering.')
    group.add_argument('--use_bias', action='store_true',
                       help='If set then use bias.')  # Added during hackathon
    # Extracted from: https://github.com/facebookresearch/llama/blob/main/llama/model.py
    group.add_argument('--use_rms_norm',
                       action='store_true',
                       help='If set, use RMSNorm instead of LayerNorm.')
    group.add_argument('--use_post_ln',
                       action='store_true',
                       help='If set, use Post-LN transformer (in the notation of https://sh-tsang.medium.com/review-pre-ln-transformer-on-layer-normalization-in-the-transformer-architecture-b6c91a89e9ab).')
    group.add_argument('--onnx_safe', type=bool, required=False,
                       help='Use workarounds for known problems with '
                       'Torch ONNX exporter')
    # Extracted from: https://github.com/bigscience-workshop/Megatron-DeepSpeed
    group.add_argument('--glu_activation', type=str,
                       choices=megatron.model.glu_activations.GLU_ACTIVATIONS.keys(),
                       help='GLU activations to use.'
                       )
    group.add_argument('--position_embedding_type', type=lambda x: PositionEmbeddingType[x],
                       choices=list(PositionEmbeddingType),
                       default=PositionEmbeddingType.absolute,
                       help='Define position embedding type ("absolute" | "rotary"). "absolute" by default.')
    group.add_argument('--rope_scaling_factor', type=float, default=1.0,
                       help='Set the linear RoPE scaling factor for sequence interpolation.')
    group.add_argument('--rope_theta', type=float, default=10000.0,
                       help='Set RoPE theta base (llama/llama2: 1e4, codellama: 1e6).')
    # Added mainly for Falcon
    group.add_argument("--parallel_attn", action="store_true",
                       help="Whether to use parallel mlp and attn computation with a single layernorm")
    group.add_argument("--parallel_layernorm", action="store_true",
                       help="Whether to use a dedicated layernorm for the mlp in the attention")
    # Added mainly for Llama
    group.add_argument("--no_tie_embed_logits", action="store_false", dest="tie_embed_logits",
                       help=("If set, the weights of the word embedding and lm_head "
                             "are not tied"))
    group.add_argument("--sliding_window_size", type=int, default=None,
                       help="Whether to use sliding window attention for Mistral. Default is None, which means no sliding window attention.")
    return parser


def _add_logging_args(parser):
    group = parser.add_argument_group(title='logging')
    group.add_argument('--log_params_norm', action='store_true',
                       help='If set, calculate and log parameters norm.')
    group.add_argument('--log_num_zeros_in_grad', action='store_true',
                       help='If set, calculate and log the number of zeros in gradient.')
    group.add_argument('--timing_log_level', type=int,
                       default=0, choices=range(0, 3),
                       help='Granularity level to measure and report timing. '
                       '   0: report only iteration time and make sure timing '
                       '      does not introduce extra overhead.'
                       '   1: report timing for operations that are executed '
                       '      very limited times (basically once) during '
                       '      each iteration (such as gradient all-reduce) '
                       '   2: report timing for operations that migh be '
                       '      executed numerous times during each iteration. '
                       'Note that setting the level to 1 or 2 might '
                       'cause increase in iteration time.')
    group.add_argument('--barrier_with_L1_time', action='store_false',
                       help='If not set, use barrier with level 1 time '
                       'measurements. Note that this is up to the user '
                       'to make sure calling barrier with their timers '
                       'will not result in hangs. This can happen if for '
                       'example the user adds a level 1 timer that is not '
                       'called by all ranks.')
    group.add_argument('--timing_log_option', type=str, default='minmax',
                       choices=['max', 'minmax', 'all'],
                       help='Options for logging timing:'
                       '  max: report the max timing across all ranks'
                       '  minmax: report min and max timings across all ranks'
                       '  all: report timings of all ranks.')
    group.add_argument('--tensorboard_log_interval', type=int, default=1,
                       help='Report to tensorboard interval.')
    group.add_argument('--tensorboard_queue_size', type=int, default=1000,
                       help='Size of the tensorboard queue for pending events '
                       'and summaries before one of the ‘add’ calls forces a '
                       'flush to disk.')
    group.add_argument('--log_timers_to_tensorboard', action='store_true',
                       help='If set, write timers to tensorboard.')
    group.add_argument('--log_batch_size_to_tensorboard', action='store_true',
                       help='If set, write batch-size to tensorboard.')
    group.add_argument('--log_validation_ppl_to_tensorboard',
                       action='store_true',
                       help='If set, write validation perplexity to '
                       'tensorboard.')
    group.add_argument('--log_memory_to_tensorboard',
                       action='store_true',
                       help='Enable memory logging to tensorboard.')
    group.add_argument('--log_world_size_to_tensorboard',
                       action='store_true',
                       help='Enable world size logging to tensorboard.')
    group.add_argument('--wandb_logger',
                       action='store_true',
                       help='Enable logging to Weights & Biases instead of tensorboard.')
    group.add_argument('--wandb_project', type=str, default=None,
                       help='Project name for Weights & Biases.')
    group.add_argument('--wandb_entity', type=str, default="meditron",
                       help='Entity/team name for Weights & Biases.')
    group.add_argument('--wandb_id',type=str,default=None,
                       help="Unique ID to identify this run, alternatively can set `WANDB_RUN_ID`.")
    group.add_argument('--wandb_resume',action="store_true",
                       help="If set, we resume logging for the id given instead of launching a new run (errors if id given and resume=False).")
    group.add_argument("--wandb_api_key",type=str,default=None,
                       help="API key for Weights & Biases, needs to be set if not set in environment variable `WANDB_API_KEY`.")
    group.add_argument("--metrics", default=[], nargs="+", choices=list(METRICS) + ["all"],
                       help="Metrics to report when logging")
    return parser


def _add_regularization_args(parser):
    group = parser.add_argument_group(title='regularization')
    group.add_argument('--attention_dropout', type=float, default=0.1,
                       help='Post attention dropout probability.')
    group.add_argument('--hidden_dropout', type=float, default=0.1,
                       help='Dropout probability for hidden state transformer.')
    # see "LIMA: Less Is More for Alignment", Zhou et al 2023, https://arxiv.org/abs/2305.11206
    group.add_argument('--lima_dropout', action='store_true',
                       help='Linearly raise the hidden_dropout probability from 0.0 at the first layer to the full hidden_dropout value at the last layer.')
    group.add_argument('--weight_decay', type=float, default=0.01,
                       help='Weight decay coefficient for L2 regularization.')
    group.add_argument('--start_weight_decay', type=float,
                       help='Initial weight decay coefficient for L2 regularization.')
    group.add_argument('--end_weight_decay', type=float,
                       help='End of run weight decay coefficient for L2 regularization.')
    group.add_argument('--weight_decay_incr_style', type=str, default='constant',
                       choices=['constant', 'linear', 'cosine'],
                       help='Weight decay increment function.')
    group.add_argument('--clip_grad', type=float, default=1.0,
                       help='Gradient clipping based on global L2 norm.')
    group.add_argument('--adam_beta1', type=float, default=0.9,
                       help='First coefficient for computing running averages '
                       'of gradient and its square')
    group.add_argument('--adam_beta2', type=float, default=0.999,
                       help='Second coefficient for computing running averages '
                       'of gradient and its square')
    group.add_argument('--adam_eps', type=float, default=1e-08,
                       help='Term added to the denominator to improve'
                       'numerical stability')
    group.add_argument('--sgd_momentum', type=float, default=0.9,
                       help='Momentum factor for sgd')

    return parser


def _add_training_args(parser):
    group = parser.add_argument_group(title='training')
    group.add_argument('--micro_batch_size', type=int, default=None,
                       help='Batch size per model instance (local batch size). '
                       'Global batch size is local batch size times data '
                       'parallel size times number of micro batches.')
    group.add_argument('--global_batch_size', type=int, default=None,
                       help='Training batch size. If set, it should be a '
                       'multiple of micro_batch_size times data-parallel-size. '
                       'If this value is None, then '
                       'use micro_batch_size * data-parallel-size as the '
                       'global batch size. This choice will result in 1 for '
                       'number of micro-batches.')
    group.add_argument('--rampup_batch_size', nargs='*', default=None,
                       help='Batch size ramp up with the following values:'
                       '  --rampup_batch_size <start batch size> '
                       '                      <batch size incerement> '
                       '                      <ramp-up samples> '
                       'For example:'
                       '   --rampup_batch_size 16 8 300000 \ '
                       '   --global_batch_size 1024'
                       'will start with global batch size 16 and over '
                       ' (1024 - 16) / 8 = 126 intervals will increase'
                       'the batch size linearly to 1024. In each interval'
                       'we will use approximately 300000 / 126 = 2380 samples.')
    group.add_argument('--recompute_activations', action='store_true',
                       help='recompute activation to allow for training '
                       'with larger models, sequences, and batch sizes.')
    group.add_argument('--recompute_granularity', type=str, default=None,
                       choices=['full', 'selective'],
                       help='Checkpoint activations to allow for training '
                       'with larger models, sequences, and batch sizes. '
                       'It is supported at two granularities 1) full: '
                       'whole transformer layer is recomputed, '
                       '2) selective: core attention part of the transformer '
                       'layer is recomputed.')
    group.add_argument('--distribute_saved_activations',
                       action='store_true',
                       help='If set, distribute recomputed activations '
                       'across model parallel group.')
    group.add_argument('--recompute_method', type=str, default=None,
                       choices=['uniform', 'block'],
                       help='1) uniform: uniformly divide the total number of '
                       'Transformer layers and recompute the input activation of '
                       'each divided chunk at specified granularity, '
                       '2) recompute the input activations of only a set number of '
                       'individual Transformer layers per pipeline stage and do the '
                       'rest without any recomputing at specified granularity'
                       'default) do not apply activations recompute to any layers')
    group.add_argument('--recompute_num_layers', type=int, default=1,
                       help='1) uniform: the number of Transformer layers in each '
                       'uniformly divided recompute unit, '
                       '2) block: the number of individual Transformer layers '
                       'to recompute within each pipeline stage.')
    group.add_argument('--train_iters', type=int, default=None,
                       help='Total number of iterations to train over all '
                       'training runs. Note that either train_iters or '
                       'train_samples should be provided.')
    group.add_argument('--skip_iters', type=int, nargs='*', default=[],
                        help=('One or more iterations to ignore. Neither the forward '
                              'nor backward pass will be computed for this iterations'))
    group.add_argument('--train_samples', type=int, default=None,
                       help='Total number of samples to train over all '
                       'training runs. Note that either train_iters or '
                       'train_samples should be provided.')
    group.add_argument('--log_interval', type=int, default=100,
                       help='Report loss and timing interval.')
    group.add_argument('--exit_interval', type=int, default=None,
                       help='Exit the program after the iteration is divisible '
                       'by this value.')
    group.add_argument('--exit_duration_in_mins', type=int, default=None,
                       help='Exit the program after this many minutes.')
    group.add_argument('--exit_signal_handler', action='store_true',
                       help='Dynamically save the checkpoint and shutdown the '
                       'training if SIGTERM is received')
    group.add_argument('--tensorboard_dir', type=str, default=None,
                       help='Write TensorBoard logs to this directory.')
    group.add_argument('--no_masked_softmax_fusion',
                       action='store_false',
                       help='Disable fusion of query_key_value scaling, '
                       'masking, and softmax.',
                       dest='masked_softmax_fusion')
    group.add_argument('--no_bias_gelu_fusion', action='store_false',
                       help='Disable bias and gelu fusion.',
                       dest='bias_gelu_fusion')
    group.add_argument('--no_bias_dropout_fusion', action='store_false',
                       help='Disable bias and dropout fusion.',
                       dest='bias_dropout_fusion')
    group.add_argument('--use_flash_attn', action='store_true',
                       help='use FlashAttention implementation of attention. '
                       'https://arxiv.org/abs/2205.14135')
    group.add_argument('--optimizer', type=str, default='adam',
                       choices=['adam', 'sgd'],
                       help='Optimizer function')
    group.add_argument('--dataloader_type', type=str, default=None,
                       choices=['single', 'cyclic'],
                       help='Single pass vs multiple pass data loader')
    group.add_argument('--no_async_tensor_model_parallel_allreduce',
                       action='store_false',
                       help='Disable asynchronous execution of '
                       'tensor-model-parallel all-reduce with weight '
                       'gradient compuation of a column-linear layer.',
                       dest='async_tensor_model_parallel_allreduce')
    group.add_argument('--no_persist_layer_norm', action='store_true',
                       help='Disable using persistent fused layer norm kernel. '
                       'This kernel supports only a set of hidden sizes. Please '
                       'check persist_ln_hidden_sizes if your hidden '
                       'size is supported.')
    group.add_argument('--sequence_parallel', action='store_true',
                       help='Enable sequence parallel optimization.')
    group.add_argument('--no_gradient_accumulation_fusion',
                       action='store_false',
                       help='Disable fusing gradient accumulation to weight '
                       'gradient computation of linear layers',
                       dest='gradient_accumulation_fusion')
    group.add_argument('--freeze_layers', action='store_true',
                       help='Freeze layers besides embedding ones.')
    return parser


def _add_initialization_args(parser):
    group = parser.add_argument_group(title='initialization')
    group.add_argument('--seed', type=int, default=1234,
                       help='Random seed used for python, numpy, '
                       'pytorch, and cuda.')
    group.add_argument('--data_parallel_random_init', action='store_true',
                       help='Enable random initialization of params '
                       'across data parallel ranks')
    group.add_argument('--init_method_std', type=float, default=0.02,
                       help='Standard deviation of the zero mean normal '
                       'distribution used for weight initialization.')
    group.add_argument('--init_method_xavier_uniform', action='store_true',
                       help='Enable Xavier uniform parameter initialization')
    return parser


def _add_learning_rate_args(parser):
    group = parser.add_argument_group(title='learning rate')
    group.add_argument('--lr', type=float, default=None,
                       help='Initial learning rate. Depending on decay style '
                       'and initial warmup, the learing rate at each '
                       'iteration would be different.')
    group.add_argument('--lr_decay_style', type=str, default='linear',
                       choices=['constant', 'linear', 'cosine', 'inverse-square-root'],
                       help='Learning rate decay function.')
    group.add_argument('--lr_decay_iters', type=int, default=None,
                       help='number of iterations to decay learning rate over,'
                       ' If None defaults to `--train_iters`')
    group.add_argument('--lr_decay_samples', type=int, default=None,
                       help='number of samples to decay learning rate over,'
                       ' If None defaults to `--train_samples`')
    group.add_argument('--lr_warmup_fraction', type=float, default=None,
                       help='fraction of lr-warmup-(iters/samples) to use '
                       'for warmup (as a float)')
    group.add_argument('--lr_warmup_iters', type=int, default=0,
                       help='number of iterations to linearly warmup '
                       'learning rate over.')
    group.add_argument('--lr_warmup_samples', type=int, default=0,
                       help='number of samples to linearly warmup '
                       'learning rate over.')
    group.add_argument('--min_lr', type=float, default=0.0,
                       help='Minumum value for learning rate. The scheduler'
                       'clip values below this threshold.')
    group.add_argument('--override_opt_param_scheduler', action='store_true',
                       help='Reset the values of the scheduler (learning rate,'
                       'warmup iterations, minimum learning rate, maximum '
                       'number of iterations, and decay style from input '
                       'arguments and ignore values from checkpoints. Note'
                       'that all the above values will be reset.')
    group.add_argument('--use_checkpoint_opt_param_scheduler', action='store_true',
                       help='Use checkpoint to set the values of the scheduler '
                       '(learning rate, warmup iterations, minimum learning '
                       'rate, maximum number of iterations, and decay style '
                       'from checkpoint and ignore input arguments.')
    group.add_argument('--annealing', action='store_true',)
    return parser


def _add_checkpointing_args(parser):
    group = parser.add_argument_group(title='checkpointing')

    group.add_argument('--save', type=str, default=None,
                       help='Output directory to save checkpoints to.')
    group.add_argument('--save_interval', type=int, default=None,
                       help='Number of iterations between checkpoint saves.')
    group.add_argument('--no_save_optim', action='store_true', default=None,
                       help='Do not save current optimizer.')
    group.add_argument('--no_save_rng', action='store_true', default=None,
                       help='Do not save current rng state.')
    group.add_argument('--load', type=str, default=None,
                       help='Directory containing a model checkpoint.')
    group.add_argument('--no_load_optim', action='store_true', default=None,
                       help='Do not load optimizer when loading checkpoint.')
    group.add_argument('--no_load_rng', action='store_true', default=None,
                       help='Do not load rng state when loading checkpoint.')
    group.add_argument('--finetune', action='store_true',
                       help='Load model for finetuning. Do not load optimizer '
                       'or rng state from checkpoint and set iteration to 0. '
                       'Assumed when loading a release checkpoint.')
    group.add_argument('--no_initialization', action='store_false',
                       help='Do not perform initialization when building model, '
                       'can reduce startup time when definitely loading from a '
                       'checkpoint',
                       dest='perform_initialization')
    group.add_argument('--use_checkpoint_args', action='store_true',
                       help='Override any command line arguments with arguments '
                       'from the checkpoint')
    return parser


def _add_mixed_precision_args(parser):
    group = parser.add_argument_group(title='mixed precision')
    group.add_argument('--fp16', action='store_true',
                       help='Run model in fp16 mode.')
    group.add_argument('--bf16', action='store_true',
                       help='Run model in bfloat16 mode.')
    group.add_argument('--loss_scale', type=float, default=None,
                       help='Static loss scaling, positive power of 2 '
                       'values can improve fp16 convergence. If None, dynamic'
                       'loss scaling is used.')
    group.add_argument('--initial_loss_scale', type=float, default=2**32,
                       help='Initial loss scale for dynamic loss scaling.')
    group.add_argument('--min_loss_scale', type=float, default=1.0,
                       help='Minimum loss scale for dynamic loss scale.')
    group.add_argument('--loss_scale_window', type=float, default=1000,
                       help='Window over which to raise/lower dynamic scale.')
    group.add_argument('--hysteresis', type=int, default=2,
                       help='hysteresis for dynamic loss scaling')
    group.add_argument('--fp32_residual_connection', action='store_true',
                       help='Move residual connections to fp32.')
    group.add_argument('--no_query_key_layer_scaling', action='store_false',
                       help='Do not scale Q * K^T by 1 / layer-number.',
                       dest='apply_query_key_layer_scaling')
    group.add_argument('--attention_softmax_in_fp32', action='store_true',
                       help='Run attention masking and softmax in fp32. '
                       'This flag is ignored unless '
                       '--no_query_key_layer_scaling is specified.')
    group.add_argument('--accumulate_allreduce_grads_in_fp32',
                       action='store_true',
                       help='Gradient accumulation and all-reduce in fp32.')
    group.add_argument('--fp16_lm_cross_entropy',
                       action='store_true',
                       help='Move the cross entropy unreduced loss calculation'
                       'for lm head to fp16.')
    return parser


def _add_distributed_args(parser):
    group = parser.add_argument_group(title='distributed')
    group.add_argument('--tensor_model_parallel_size', type=int, default=1,
                       help='Degree of tensor model parallelism.')
    group.add_argument('--pipeline_model_parallel_size', type=int, default=1,
                       help='Degree of pipeline model parallelism.')
    group.add_argument('--pipeline_model_parallel_split_rank',
                       type=int, default=None,
                       help='Rank where encoder and decoder should be split.')
    group.add_argument('--num_layers_per_virtual_pipeline_stage', type=int, default=None,
                       help='Number of layers per virtual pipeline stage')
    group.add_argument('--distributed_backend', default='nccl',
                       choices=['nccl', 'gloo'],
                       help='Which backend to use for distributed training.')
    group.add_argument('--DDP_impl', default='local',
                       choices=['local', 'torch'],
                       help='which DistributedDataParallel implementation '
                       'to use.')
    group.add_argument('--no_contiguous_buffers_in_local_ddp',
                       action='store_false', help='If set, dont use '
                       'contiguous buffer in local DDP.',
                       dest='use_contiguous_buffers_in_local_ddp')
    group.add_argument('--no_scatter_gather_tensors_in_pipeline',
                       action='store_false',
                       help='Use scatter/gather to optimize communication of tensors in pipeline',
                       dest='scatter_gather_tensors_in_pipeline')
    group.add_argument('--use_ring_exchange_p2p', action='store_true',
                       default=False, help='If set, use custom-built ring exchange '
                       'for p2p communications. Note that this option will require '
                       'a custom built image that support ring-exchange p2p.')
    group.add_argument('--local_rank', type=int, default=None,
                       help='local rank passed from distributed launcher.')
    group.add_argument('--use_cpu_initialization', action='store_true',
                       default=None, help='If set, affine parallel weights '
                       'initialization uses CPU')
    group.add_argument('--empty_unused_memory_level', default=0, type=int,
                       choices=[0, 1, 2],
                       help='Call torch.cuda.empty_cache() each iteration '
                       '(training and eval), to reduce fragmentation.'
                       '0=off, 1=moderate, 2=aggressive.')
    group.add_argument('--standalone_embedding_stage', action='store_true',
                       default=False, help='If set, *input* embedding layer '
                       'is placed on its own pipeline stage, without any '
                       'transformer layers. (For T5, this flag currently only '
                       'affects the encoder embedding.)')
    group.add_argument('--use_distributed_optimizer', action='store_true',
                       help='Use distributed optimizer.')
    return parser


def _add_validation_args(parser):
    group = parser.add_argument_group(title='validation')
    group.add_argument('--eval_iters', type=int, default=100,
                       help='Number of iterations to run for evaluation'
                       'validation/test for.')
    group.add_argument('--eval_interval', type=int, default=1000,
                       help='Interval between running evaluation on '
                       'validation set.')
    return parser


def _add_data_args(parser):
    group = parser.add_argument_group(title='data and dataloader')
    group.add_argument('--data_path', nargs='*', default=None,
                       help='Path to the training dataset. Accepted format:'
                       '1) a single data path, 2) multiple datasets in the'
                       'form: dataset1-weight dataset1-path dataset2-weight '
                       'dataset2-path ... It is used with --split when a '
                       'single dataset used for all three: train, valid '
                       'and test. It is exclusive to the other '
                       '--*-data_path args')
    group.add_argument('--split', type=str, default='969, 30, 1',
                       help='Comma-separated list of proportions for training,'
                       ' validation, and test split. For example the split '
                       '`90,5,5` will use 90%% of data for training, 5%% for '
                       'validation and 5%% for test.')
    group.add_argument('--train_data_path', nargs='*', default=None,
                       help='Path to the training dataset. Accepted format:'
                       '1) a single data path, 2) multiple datasets in the'
                       'form: dataset1-weight dataset1-path dataset2-weight '
                       'dataset2-path ...')
    group.add_argument('--valid_data_path', nargs='*', default=None,
                       help='Path to the validation dataset. Accepted format:'
                       '1) a single data path, 2) multiple datasets in the'
                       'form: dataset1-weight dataset1-path dataset2-weight '
                       'dataset2-path ...')
    group.add_argument('--test_data_path', nargs='*', default=None,
                       help='Path to the test dataset. Accepted format:'
                       '1) a single data path, 2) multiple datasets in the'
                       'form: dataset1-weight dataset1-path dataset2-weight '
                       'dataset2-path ...')
    group.add_argument('--vocab_file', type=str, default=None,
                       help='Path to the vocab file.')
    group.add_argument('--merge_file', type=str, default=None,
                       help='Path to the BPE merge file.')
    group.add_argument('--vocab_extra_ids', type=int, default=0,
                       help='Number of additional vocabulary tokens. '
                            'They are used for span masking in the T5 model')
    group.add_argument('--vocab_extra_ids_list', type=str, default=None,
                       help='comma separated list of special vocab ids to add to the tokenizer')
    group.add_argument('--seq_length', type=int, default=None,
                       help='Maximum sequence length to process.')
    group.add_argument('--variable_seq_lengths', action='store_true', default=None,
                       help='Enable variable sequence lengths.')
    group.add_argument('--scalar_loss_mask', type=float, default=0.0,
                       help=('Instruction-tuning argument: Scalar to multiply the '
                             'loss of the "masked out" tokens (usually the user '
                             'tokens, not assistant ones). Set to zero (default) '
                             'to completely remove the loss of said tokens'))
    group.add_argument('--encoder_seq_length', type=int, default=None,
                       help='Maximum encoder sequence length to process.'
                       'This should be exclusive of --seq_length')
    group.add_argument('--decoder_seq_length', type=int, default=None,
                       help="Maximum decoder sequence length to process.")
    group.add_argument('--retriever_seq_length', type=int, default=256,
                       help='Maximum sequence length for the biencoder model '
                       'for retriever')
    group.add_argument('--sample_rate', type=float, default=1.0,
                       help='sample rate for training data. Supposed to be 0 '
                            ' < sample_rate < 1')
    group.add_argument('--mask_prob', type=float, default=0.15,
                       help='Probability of replacing a token with mask.')
    group.add_argument('--short_seq_prob', type=float, default=0.1,
                       help='Probability of producing a short sequence.')
    group.add_argument('--mmap_warmup', action='store_true',
                       help='Warm up mmap files.')
    group.add_argument('--num_workers', type=int, default=2,
                       help="Dataloader number of workers.")
    group.add_argument('--tokenizer_type', type=str,
                       default=None,
                       choices=['BertWordPieceLowerCase',
                                'BertWordPieceCase',
                                'GPT2BPETokenizer',
                                'SentencePieceTokenizer',
                                'PretrainedFromHF',
                                'FalconTokenizer'],
                       help='What type of tokenizer to use.')
    group.add_argument('--tokenizer_model', type=str, default=None,
                       help='Sentencepiece tokenizer model.')
    group.add_argument("--no_new_tokens", action="store_false", dest="new_tokens",
                       help=("Do not add special tokens (e.g. CLS, MASK, etc) "
                             "in the sentenciepiece tokenizer"))
    group.add_argument('--data_impl', type=str, default='infer',
                       choices=['lazy', 'cached', 'mmap', 'infer'],
                       help='Implementation of indexed datasets.')
    group.add_argument('--reset_position_ids', action='store_true',
                       help='Reset posistion ids after end-of-document token.')
    group.add_argument('--reset_attention_mask', action='store_true',
                       help='Reset self attention maske after '
                       'end-of-document token.')
    group.add_argument('--eod_mask_loss', action='store_true',
                       help='Mask loss for the end of document tokens.')
    return parser


def _add_autoresume_args(parser):
    group = parser.add_argument_group(title='autoresume')
    group.add_argument('--adlr_autoresume', action='store_true',
                       help='Enable autoresume on adlr cluster.')
    group.add_argument('--adlr_autoresume_interval', type=int, default=1000,
                       help='Intervals over which check for autoresume'
                       'termination signal')
    return parser


def _add_biencoder_args(parser):
    group = parser.add_argument_group(title='biencoder')
    # network size
    group.add_argument('--ict_head_size', type=int, default=None,
                       help='Size of block embeddings to be used in ICT and '
                        'REALM (paper default: 128)')
    group.add_argument('--biencoder_projection_dim', type=int, default=0,
                       help='Size of projection head used in biencoder')
    group.add_argument('--biencoder_shared_query_context_model', action='store_true',
                        help='Whether to share the parameters of the query '
                        'and context models or not')
    # checkpointing
    group.add_argument('--ict_load', type=str, default=None,
                       help='Directory containing an ICTBertModel checkpoint')
    group.add_argument('--bert_load', type=str, default=None,
                       help='Directory containing an BertModel checkpoint '
                       '(needed to start ICT and REALM)')

    # data
    group.add_argument('--titles_data_path', type=str, default=None,
                       help='Path to titles dataset used for ICT')
    group.add_argument('--query_in_block_prob', type=float, default=0.1,
                       help='Probability of keeping query in block for '
                       'ICT dataset')
    group.add_argument('--use_one_sent_docs', action='store_true',
                       help='Whether to use one sentence documents in ICT')
    group.add_argument('--evidence_data_path', type=str, default=None,
                       help='Path to Wikipedia Evidence frm DPR paper')

    # training
    group.add_argument('--retriever_report_topk_accuracies', nargs='+', type=int,
                        default=[], help="Which top-k accuracies to report "
                        "(e.g. '1 5 20')")
    group.add_argument('--retriever_score_scaling', action='store_true',
                       help='Whether to scale retriever scores by inverse '
                        'square root of hidden size')

    # faiss index
    group.add_argument('--block_data_path', type=str, default=None,
                       help='Where to save/load BlockData to/from')
    group.add_argument('--embedding_path', type=str, default=None,
                       help='Where to save/load Open-Retrieval Embedding'
                        ' data to/from')

    # indexer
    group.add_argument('--indexer_batch_size', type=int, default=128,
                       help='How large of batches to use when doing indexing '
                       'jobs')
    group.add_argument('--indexer_log_interval', type=int, default=1000,
                       help='After how many batches should the indexer '
                       'report progress')
    return parser


def _add_vision_args(parser):
    group = parser.add_argument_group(title="vision")

    # general vision arguements
    group.add_argument('--num_classes', type=int, default=1000,
                       help='num of classes in vision classificaiton task')
    group.add_argument('--img_h', type=int, default=224,
                       help='Image height for vision classification task')
    group.add_argument('--img_w', type=int, default=224,
                       help='Image height for vision classification task')
    group.add_argument('--num_channels', type=int, default=3,
                       help='Number of channels in input image data')
    group.add_argument('--patch_dim', type=int, default=16,
                       help='patch dimension')
    group.add_argument('--classes_fraction', type=float, default=1.0,
                       help='training with fraction of classes.')
    group.add_argument('--data_per_class_fraction', type=float, default=1.0,
                       help='training with fraction of data per class.')
    group.add_argument('--no_data_sharding', action='store_false',
                       help='Disable data sharding.',
                       dest='data_sharding')
    group.add_argument('--head_lr_mult', type=float, default=1.0,
                       help='learning rate multiplier for head during finetuning')

    # dino arguments
    group.add_argument('--iter_per_epoch', type=int, default=1250,
                       help='iterations per epoch')
    group.add_argument('--dino_local_img_size', type=int, default=96,
                       help='Image size for vision classification task')
    group.add_argument('--dino_local_crops_number', type=int, default=10,
                       help='Number of local crops')
    group.add_argument('--dino_head_hidden_size', type=int, default=2048,
                       help='Hidden dimension size in dino head')
    group.add_argument('--dino_bottleneck_size', type=int, default=256,
                       help='Bottle neck dimension in dino head ')
    group.add_argument('--dino_freeze_last_layer', type=float, default=1,
                       help='Freezing last layer weights')
    group.add_argument('--dino_norm_last_layer', action='store_true',
                       help='Disable Norm in last layer.')
    group.add_argument('--dino_warmup_teacher_temp', type=float, default=0.04,
                       help='warump teacher temperature')
    group.add_argument('--dino_teacher_temp', type=float, default=0.07,
                       help='teacher temperature')
    group.add_argument('--dino_warmup_teacher_temp_epochs', type=int, default=30,
                       help='warmup teacher temperaure epochs')
    return parser