def add_args(parser):
"""Add task-specific arguments to the parser."""
TranslationTask.add_args(parser)
parser.add_argument(
'--noise',
default='no_noise',
choices=['random_mask', 'no_noise', 'full_mask'])
def add_args(parser):
"""Add task-specific arguments to the parser."""
# fmt: off
TranslationTask.add_args(parser)
parser.add_argument(
'--remove-eos-from-source',
action='store_true',
help='if set, remove eos from end of source if it\'s present')
parser.add_argument('--load-dependency',
action='store_true',
help='load the dependency heads')
parser.add_argument(
'--dependency-with-input',
action='store_true',
help='if set, target-side\'s dependencies are based on the inputs')
parser.add_argument(
'--use-gold-dependency',
action='store_true',
help='use the source\'s gold dependency for inference')
parser.add_argument(
'--print-dependency',
nargs='?',
const='hard',
help=
'if set, uses attention feedback to compute and print dependency')
def add_args(parser):
"""Add task-specific arguments to the parser."""
# fmt: off
TranslationTask.add_args(parser)
parser.add_argument(
'--noise',
default='random_delete',
choices=['random_delete', 'random_mask', 'no_noise', 'full_mask'])
parser.add_argument('--add-mask-token',
action='store_true',
help='add a mask token for model compatibility.')
parser.add_argument('--use-mask-token',
default=False,
action='store_true')
parser.add_argument('--add-lang-token',
default=False,
action='store_true')
parser.add_argument('--use-lang-token',
default=False,
action='store_true')
parser.add_argument(
'--langs',
default=None,
metavar='LANG',
help=
'comma-separated list of monolingual language, for example, "en,de,fr"'
'be careful these langs are what you used for pretraining (the same order),'
'not for finetuning.'
'you should always add all pretraining language idx during finetuning.'
)
def add_args(parser):
"""Add task-specific arguments to the parser."""
# fmt: off
TranslationTask.add_args(parser)
parser.add_argument(
'--langs',
required=True,
metavar='LANG',
help='comma-separated list of monolingual language, '
'for example, "en,de,fr". These should match the '
'langs from pretraining (and be in the same order). '
'You should always add all pretraining language idx '
'during finetuning.')
parser.add_argument(
'--extra-lang-symbol',
default='',
type=str,
help='comma-separated list of monolingual language, '
'for example, "en,de,fr". These should match the '
'langs from pretraining (and be in the same order). '
'You should always add all pretraining language idx '
'during finetuning.')
parser.add_argument(
'--prepend-bos',
action='store_true',
help='prepend bos token to each sentence, which matches '
'mBART pretraining')
def add_args(parser):
"""Add task-specific arguments to the parser."""
# fmt: off
TranslationTask.add_args(parser)
parser.add_argument('--method',
default='hMoEup',
choices=['sMoElp', 'sMoEup', 'hMoElp', 'hMoEup'])
parser.add_argument('--num-experts',
default=3,
type=int,
metavar='N',
help='number of experts')
parser.add_argument('--mean-pool-gating-network',
action='store_true',
help='use a simple mean-pooling gating network')
parser.add_argument('--mean-pool-gating-network-dropout',
type=float,
help='dropout for mean-pooling gating network')
parser.add_argument(
'--mean-pool-gating-network-encoder-dim',
type=float,
help='encoder output dim for mean-pooling gating network')
parser.add_argument('--gen-expert',
type=int,
default=0,
help='which expert to use for generation')
def add_args(parser):
TranslationTask.add_args(parser)
parser.add_argument('--morpho-dropout', type=float, default=0.5)
parser.add_argument('--morpho-dropout-initial',
type=float,
default=None)
parser.add_argument('--morpho-dropout-end-epoch',
type=int,
default=None)
def add_args(parser):
"""Add task-specific arguments to the parser."""
# fmt: off
TranslationTask.add_args(parser)
parser.add_argument('--noise',
default='random_delete',
choices=[
'random_delete', 'random_delete_shuffle',
'random_mask', 'no_noise', 'full_mask'
])
parser.add_argument('--random-seed', default=1, type=int)
def add_args(parser):
"""Add task-specific arguments to the parser."""
TranslationTask.add_args(parser)
parser.add_argument(
'--langs',
required=True,
metavar='LANG',
help='comma-separated list of monolingual language, '
'for example, "en,de,fr". These should match the '
'langs from pretraining (and be in the same order). '
'You should always add all pretraining language idx '
'during finetuning.')
def add_args(parser):
"""Add task-specific arguments to the parser."""
# fmt: off
TranslationTask.add_args(parser)
parser.add_argument('--bert-model',
type=str,
metavar='DIR',
required=True,
help='path to the BERT model')
parser.add_argument('--fine-tuning',
action='store_true',
help='if set, the BERT model will be tuned')
parser.set_defaults(left_pad_source=False)
def add_args(parser):
"""Add task-specific arguments to the parser."""
# fmt: off
TranslationTask.add_args(parser)
parser.add_argument(
'--noise',
default='random_delete',
choices=['random_delete', 'random_mask', 'no_noise', 'full_mask'])
parser.add_argument('--append_eos_to_target',
default=True,
type=bool,
help="the path of the mean file.")
parser.add_argument('--append_bos_to_target',
default=True,
type=bool,
help="the path of the mean file.")
def add_args(parser):
"""Add task-specific arguments to the parser."""
# fmt: off
TranslationTask.add_args(parser)
# Training:
parser.add_argument('--pretrained', default=None, type=str)
parser.add_argument('--copy-embeddings', action='store_true')
parser.add_argument('--copy-network', action='store_true')
parser.add_argument('--shift', default=1, type=int)
parser.add_argument('--policy', default='eos', type=str)
parser.add_argument('--write-threshold', default=0.5, type=float)
parser.add_argument('--align-index', default=1, type=int)
parser.add_argument('--pick-alignment', default='index', type=str)
parser.add_argument('--path-oracle', default='alignment', type=str)
parser.add_argument('--path-oracle-rank', default=50, type=int)
parser.add_argument('--path-oracle-tol', default=0.1, type=float)
parser.add_argument('--path-oracle-lookahead', default=0, type=int)
parser.add_argument('--path-oracle-waitk', default=7, type=int)
parser.add_argument('--path-oracle-width', default=3, type=int)
def add_args(parser):
"""Add task-specific arguments to the parser."""
# fmt: off
TranslationTask.add_args(parser)
parser.add_argument('--mono-data',
default=None,
help='monolingual data, split by :')
parser.add_argument(
'--mono-one-split-each-epoch',
action='store_true',
default=False,
help='use on split of monolingual data at each epoch')
parser.add_argument('--parallel-ratio',
default=1.0,
type=float,
help='subsample ratio of parallel data')
parser.add_argument('--mono-ratio',
default=1.0,
type=float,
help='subsample ratio of mono data')
def add_args(parser):
"""Add task-specific arguments to the parser."""
# fmt: off
TranslationTask.add_args(parser)
parser.add_argument(
'--noise',
default='random_delete',
choices=['random_delete', 'random_mask', 'no_noise', 'full_mask'])
parser.add_argument('--shape_size',
default=224,
type=int,
help="the shape size of image")
parser.add_argument(
'--sample-startegy',
default="sampling_with_tgt_len",
type=str,
choices=["sampling_with_tgt_len", "sampling_with_src_len"],
help="sampling frames from the video")
parser.add_argument(
'--tgtlen-times',
default=5,
type=int,
help=
"The maximum number of frames of the source video is 'tgtlen_times' times"
"the length of the target sentence, if use, the sample_startegy must be "
"sampling_with_tgt_len")
parser.add_argument('--mean-img-file',
default=None,
type=str,
help="the path of the mean file.")
parser.add_argument('--append_eos_to_target',
default=True,
type=bool,
help="the path of the mean file.")
parser.add_argument('--append_bos_to_target',
default=True,
type=bool,
help="the path of the mean file.")
def add_args(parser):
"""Add task-specific arguments to the parser."""
# fmt: off
TranslationTask.add_args(parser)
parser.add_argument(
'--langs',
type=str,
metavar='LANG',
help='comma-separated list of monolingual language, '
'for example, "en,de,fr". These should match the '
'langs from pretraining (and be in the same order). '
'You should always add all pretraining language idx '
'during finetuning.')
parser.add_argument(
'--prepend-bos',
action='store_true',
help='prepend bos token to each sentence, which matches '
'mBART pretraining')
parser.add_argument(
'--domain-dict',
type=str,
required=True,
help=
'Path a file that contains a list of all domains (same format as dict.txt)'
)
parser.add_argument(
'--train-domains',
type=str,
required=True,
help='File of same line count as training split where each '
'line has some domain from the domain_dict.txt')
parser.add_argument(
'--valid-domains',
type=str,
required=True,
help='File of same line count as validation split where each '
'line has some domain from the domain_dict.txt')
def add_args(parser):
TranslationTask.add_args(parser)
parser.add_argument('--without-padding', action='store_true', help='load the dataset lazily')
def add_args(parser):
"""Add task-specific arguments to the parser."""
TranslationTask.add_args(parser)
# fmt: off
parser.add_argument(
'--channel-model',
metavar='FILE',
help=
'path to P(S|T) model. P(S|T) and P(T|S) must share source and target dictionaries.'
)
parser.add_argument(
'--combine-method',
default='lm_only',
choices=['lm_only', 'noisy_channel'],
help="""method for combining direct and channel model scores.
lm_only: decode with P(T|S)P(T)
noisy_channel: decode with 1/t P(T|S) + 1/s(P(S|T)P(T))"""
)
parser.add_argument(
'--normalize-lm-scores-by-tgt-len',
action='store_true',
default=False,
help='normalize lm score by target length instead of source length'
)
parser.add_argument(
'--channel-scoring-type',
default='log_norm',
choices=[
'unnormalized', 'log_norm', 'k2_separate', 'src_vocab',
'src_vocab_batched'
],
help=
"Normalize bw scores with log softmax or return bw scores without log softmax"
)
parser.add_argument(
'--top-k-vocab',
default=0,
type=int,
help=
'top k vocab IDs to use with `src_vocab` in channel model scoring')
parser.add_argument(
'--k2',
default=50,
type=int,
help=
'the top k2 candidates to rescore with the noisy channel model for each beam'
)
parser.add_argument('--ch-wt',
default=1,
type=float,
help='weight for the channel model')
parser.add_argument(
'--lm-model',
metavar='FILE',
help=
'path to lm model file, to model P(T). P(T) must share the same vocab as the direct model on the target side'
)
parser.add_argument(
'--lm-data',
metavar='FILE',
help=
'path to lm model training data for target language, used to properly load LM with correct dictionary'
)
parser.add_argument('--lm-wt',
default=1,
type=float,
help='the weight of the lm in joint decoding')
def add_args(parser):
TranslationTask.add_args(parser)
# bart setting
parser.add_argument(
"--mask",
default=0.0,
type=float,
help="fraction of words/subwords that will be masked",
)
parser.add_argument(
"--mask-random",
default=0.0,
type=float,
help="instead of using [MASK], use random token this often",
)
parser.add_argument(
"--insert",
default=0.0,
type=float,
help="insert this percentage of additional random tokens",
)
parser.add_argument(
"--poisson-lambda",
default=3.0,
type=float,
help="randomly shuffle sentences for this proportion of inputs",
)
parser.add_argument(
"--mask-length",
default="span-poisson",
type=str,
choices=["subword", "word", "span-poisson"],
help="mask length to choose",
)
parser.add_argument(
"--replace-length",
default=1,
type=int,
help=
"when masking N tokens, replace with 0, 1, or N tokens (use -1 for N)",
)
# multi-lingual
parser.add_argument(
"--multilang-sampling-alpha",
type=float,
default=1.0,
help="smoothing alpha for sample ratios across multiple datasets",
)
parser.add_argument(
"--lang-pairs",
default="",
metavar="PAIRS",
help=
"comma-separated list of language pairs (in training order): phnen-en,phnfr-fr,phnit-it. Do masking",
)
parser.add_argument(
"--lang-pairs-bitext",
default="",
metavar="PAIRS",
help=
"comma-separated list of language pairs (in training order): en-de,en-fr,de-fr. No masking",
)
parser.add_argument("--add-src-lang-token",
default=False,
action="store_true")
parser.add_argument("--add-tgt-lang-token",
default=False,
action="store_true")
parser.add_argument(
"--no-whole-word-mask-langs",
type=str,
default="",
metavar="N",
help=
"languages without spacing between words dont support whole word masking",
)
parser.add_argument("--use-mask-whole-words",
default=False,
action="store_true")
def add_args(parser):
TranslationTask.add_args(parser)
pass
def add_args(parser):
"""Add task-specific arguments to the parser."""
TranslationTask.add_args(parser)
parser.add_argument('--eval-waitk', default=3, type=int)
def add_args(parser):
"""Add task-specific arguments to the parser."""
# fmt: off
TranslationTask.add_args(parser)
parser.add_argument('--forget-rate',
type=float,
default=0.9,
metavar='D',
help='rho = (t + decay)^{-forget}')
parser.add_argument('--decay-rate',
type=float,
default=1.,
metavar='D',
help='rho = (t + decay)^{-forget}')
parser.add_argument('--retrieve-split',
type=str,
default='train',
help='the retrieve pool')
parser.add_argument('--dec-opt-freq',
type=int,
default=1,
help='the relative update freq of decoder')
parser.add_argument('--enc-opt-freq',
type=int,
default=1,
help='the relative update freq of encoder')
parser.add_argument('--iw-nsamples',
type=int,
default=1000,
help='number of importance-weighted samples')
parser.add_argument('--eval-mode',
type=str,
default='none',
choices=[
'iw', 'entropy', 'gen_sample',
'gen_reconstruction', 'time', 'none',
'from_file', 'gen_interpolation'
],
help='evaluation modes')
parser.add_argument('--eval-gen-file',
type=str,
default=None,
help='read in prototypes and edit vectors')
parser.add_argument('--eval-gen-edit-vec',
action='store_true',
default=False,
help='write edit vectors in the generation file')
parser.add_argument(
'--prune-num',
type=int,
default=-1,
help='perform evaluation based on top prune_num templates only')
# parser.add_argument('--prune-num-offline', type=int, default=-1,
# help='perform evaluation based on top prune_num templates only (offline version)')
parser.add_argument(
'--free-bits',
type=float,
default=0,
help='the free bits param to regularize KLt, 0 to disable')
parser.add_argument(
'--lambda-t-config',
default="1.0",
type=str,
metavar='CONFIG',
help='KLt coefficient '
'use fixed weight during training if set to floating point number. '
'use piecewise linear function over number of updates to schedule the '
'weight with the format: w0:step0,w1:step1,...')
parser.add_argument(
'--gen-nz',
type=int,
default=10,
help='number of edit vector samples to draw from the prior')
parser.add_argument('--gen-np',
type=int,
default=200,
help='number of top prototypes')
parser.add_argument(
'--write-loss-path',
type=str,
default=None,
help='write out loss at evaluation time for interpolation exp')