code stringlengths 17 6.64M |
|---|
class Adafactor(torch.optim.Optimizer):
'Implements Adafactor algorithm.\n\n This implementation is based on:\n `Adafactor: Adaptive Learning Rates with Sublinear Memory Cost`\n (see https://arxiv.org/abs/1804.04235)\n\n Arguments:\n params (iterable): iterable of parameters to optimize or dict... |
@register_optimizer('adagrad')
class Adagrad(FairseqOptimizer):
def __init__(self, args, params):
super().__init__(args)
self._optimizer = torch.optim.Adagrad(params, **self.optimizer_config)
@staticmethod
def add_args(parser):
'Add optimizer-specific arguments to the parser.'
... |
@register_optimizer('adam')
class FairseqAdam(FairseqOptimizer):
'Adam optimizer for fairseq.\n\n Important note: this optimizer corresponds to the "AdamW" variant of\n Adam in its weight decay behavior. As such, it is most closely\n analogous to torch.optim.AdamW from PyTorch.\n '
def __init__(s... |
class Adam(torch.optim.Optimizer):
'Implements Adam algorithm.\n\n This implementation is modified from torch.optim.Adam based on:\n `Fixed Weight Decay Regularization in Adam`\n (see https://arxiv.org/abs/1711.05101)\n\n It has been proposed in `Adam: A Method for Stochastic Optimization`_.\n\n Ar... |
@register_optimizer('adamax')
class FairseqAdamax(FairseqOptimizer):
def __init__(self, args, params):
super().__init__(args)
self._optimizer = Adamax(params, **self.optimizer_config)
@staticmethod
def add_args(parser):
'Add optimizer-specific arguments to the parser.'
pa... |
class Adamax(torch.optim.Optimizer):
'Implements Adamax algorithm (a variant of Adam based on infinity norm).\n\n It has been proposed in `Adam: A Method for Stochastic Optimization`__.\n\n Compared to the version in PyTorch, this version implements a fix for weight decay.\n\n Arguments:\n params ... |
class FairseqBMUF(FairseqOptimizer):
'\n Implements incremental block distributed data parallelism similar to\n https://ieeexplore.ieee.org/document/7472805\n\n Paper title: Scalable training of deep learning machines by incremental\n block training with intra-block parallel optimization and blockwise... |
class FairseqOptimizer(object):
def __init__(self, args):
super().__init__()
self.args = args
@staticmethod
def add_args(parser):
'Add optimizer-specific arguments to the parser.'
pass
@property
def optimizer(self):
'Return a torch.optim.optimizer.Optimiz... |
class DynamicLossScaler(object):
def __init__(self, init_scale=(2.0 ** 15), scale_factor=2.0, scale_window=2000, tolerance=0.05, threshold=None):
self.loss_scale = init_scale
self.scale_factor = scale_factor
self.scale_window = scale_window
self.tolerance = tolerance
self.... |
class _FP16OptimizerMixin(object):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
@property
def has_flat_params(self):
return torch.is_tensor(self.fp32_params)
@classmethod
def build_fp32_params(cls, params, flatten=True):
if flatten:
... |
class FP16Optimizer(_FP16OptimizerMixin, optim.FairseqOptimizer):
'\n Wrap an *optimizer* to support FP16 (mixed precision) training.\n '
def __init__(self, args, params, fp32_optimizer, fp32_params):
super().__init__(args)
self.fp16_params = params
self.fp32_optimizer = fp32_op... |
class _MemoryEfficientFP16OptimizerMixin(object):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
@property
def has_flat_params(self):
return False
def state_dict(self):
"Return the optimizer's state dict."
state_dict = self.wrapped_optimizer.s... |
class MemoryEfficientFP16Optimizer(_MemoryEfficientFP16OptimizerMixin, optim.FairseqOptimizer):
'\n Wrap an *optimizer* to support FP16 (mixed precision) training.\n\n Compared to :class:`fairseq.optim.FP16Optimizer`, this version does not\n maintain an FP32 copy of the model. We instead expect the optim... |
def get_fused_adam_class():
'\n Look for the FusedAdam optimizer from apex. We first try to load the\n "contrib" interface, which is a bit faster than the main interface,\n but is technically deprecated.\n '
try:
global fused_adam_cuda
import importlib
fused_adam_cuda = imp... |
class FusedAdamV1(torch.optim.Optimizer):
"\n Implements Adam algorithm. Currently GPU-only. Requires Apex to be installed via\n ``python setup.py install --cuda_ext --cpp_ext``.\n\n It has been proposed in `Adam: A Method for Stochastic Optimization`_.\n\n Compared to the original version in Apex, th... |
@register_optimizer('lamb')
class FairseqLAMB(FairseqOptimizer):
'LAMB optimizer.'
def __init__(self, args, params):
super().__init__(args)
try:
from apex.optimizers import FusedLAMB
self._optimizer = FusedLAMB(params, **self.optimizer_config)
except ImportErro... |
@register_lr_scheduler('cosine')
class CosineSchedule(FairseqLRScheduler):
'Assign LR based on a cyclical schedule that follows the cosine function.\n\n See https://arxiv.org/pdf/1608.03983.pdf for details.\n\n We also support a warmup phase where we linearly increase the learning rate\n from some initia... |
class FairseqLRScheduler(object):
def __init__(self, args, optimizer):
super().__init__()
if (not isinstance(optimizer, FairseqOptimizer)):
raise ValueError('optimizer must be an instance of FairseqOptimizer')
self.args = args
self.optimizer = optimizer
self.be... |
@register_lr_scheduler('fixed')
class FixedSchedule(FairseqLRScheduler):
'Decay the LR on a fixed schedule.'
def __init__(self, args, optimizer):
super().__init__(args, optimizer)
args.warmup_updates = (getattr(args, 'warmup_updates', 0) or 0)
self.lr = args.lr[0]
if (args.war... |
@register_lr_scheduler('inverse_sqrt')
class InverseSquareRootSchedule(FairseqLRScheduler):
'Decay the LR based on the inverse square root of the update number.\n\n We also support a warmup phase where we linearly increase the learning rate\n from some initial learning rate (``--warmup-init-lr``) until the ... |
@register_lr_scheduler('linear')
class LinearSchedule(FairseqLRScheduler):
'Decay the LR linearly based on the update number.\n\n We also support a warmup phase where we linearly increase the learning rate\n from some initial learning rate (``--warmup-init-lr``) until the configured\n learning rate (``--... |
@register_lr_scheduler('polynomial_decay')
class PolynomialDecaySchedule(FairseqLRScheduler):
'Decay the LR on a fixed schedule.'
def __init__(self, args, optimizer):
super().__init__(args, optimizer)
args.warmup_updates = (getattr(args, 'warmup_updates', 0) or 0)
self.lr = args.lr[0]... |
@register_lr_scheduler('reduce_lr_on_plateau')
class ReduceLROnPlateau(FairseqLRScheduler):
'\n Decay the LR by a factor every time the validation loss plateaus.\n Also comes with optional warmup phase, where we linearly increase the learning rate\n from some initial learning rate (``--warmup-init-lr``) ... |
@register_lr_scheduler('tri_stage')
class TriStageLRSchedule(FairseqLRScheduler):
'Tristage learning rate schedulr\n\n Implement the learning rate scheduler in https://arxiv.org/pdf/1904.08779.pdf\n\n Similar to inverse_squre_root scheduler, but tri_stage learning rate employs\n three stages LR schedulin... |
@register_lr_scheduler('triangular')
class TriangularSchedule(FairseqLRScheduler):
'Assign LR based on a triangular cyclical schedule.\n\n See https://arxiv.org/pdf/1506.01186.pdf for details.\n '
def __init__(self, args, optimizer):
super().__init__(args, optimizer)
if (len(args.lr) > ... |
@register_optimizer('nag')
class FairseqNAG(FairseqOptimizer):
def __init__(self, args, params):
super().__init__(args)
self._optimizer = NAG(params, **self.optimizer_config)
@staticmethod
def add_args(parser):
'Add optimizer-specific arguments to the parser.'
parser.add_... |
class NAG(Optimizer):
def __init__(self, params, lr=required, momentum=0, weight_decay=0):
defaults = dict(lr=lr, lr_old=lr, momentum=momentum, weight_decay=weight_decay)
super(NAG, self).__init__(params, defaults)
@property
def supports_memory_efficient_fp16(self):
return True
... |
@register_optimizer('sgd')
class SGD(FairseqOptimizer):
def __init__(self, args, params):
super().__init__(args)
self._optimizer = torch.optim.SGD(params, **self.optimizer_config)
@staticmethod
def add_args(parser):
'Add optimizer-specific arguments to the parser.'
parser... |
def get_preprocessing_parser(default_task='translation'):
parser = get_parser('Preprocessing', default_task)
add_preprocess_args(parser)
return parser
|
def get_training_parser(default_task='translation'):
parser = get_parser('Trainer', default_task)
add_dataset_args(parser, train=True)
add_distributed_training_args(parser)
add_model_args(parser)
add_optimization_args(parser)
add_checkpoint_args(parser)
return parser
|
def get_generation_parser(interactive=False, default_task='translation'):
parser = get_parser('Generation', default_task)
add_dataset_args(parser, gen=True)
add_generation_args(parser)
if interactive:
add_interactive_args(parser)
return parser
|
def get_interactive_generation_parser(default_task='translation'):
return get_generation_parser(interactive=True, default_task=default_task)
|
def get_eval_lm_parser(default_task='language_modeling'):
parser = get_parser('Evaluate Language Model', default_task)
add_dataset_args(parser, gen=True)
add_eval_lm_args(parser)
return parser
|
def get_validation_parser(default_task=None):
parser = get_parser('Validation', default_task)
add_dataset_args(parser, train=True)
group = parser.add_argument_group('Evaluation')
add_common_eval_args(group)
return parser
|
def eval_str_list(x, type=float):
if (x is None):
return None
if isinstance(x, str):
x = eval(x)
try:
return list(map(type, x))
except TypeError:
return [type(x)]
|
def eval_bool(x, default=False):
if (x is None):
return default
try:
return bool(eval(x))
except TypeError:
return default
|
def parse_args_and_arch(parser: argparse.ArgumentParser, input_args: List[str]=None, parse_known: bool=False, suppress_defaults: bool=False, modify_parser: Optional[Callable[([argparse.ArgumentParser], None)]]=None):
'\n Args:\n parser (ArgumentParser): the parser\n input_args (List[str]): string... |
def get_parser(desc, default_task='translation'):
usr_parser = argparse.ArgumentParser(add_help=False, allow_abbrev=False)
usr_parser.add_argument('--user-dir', default=None)
(usr_args, _) = usr_parser.parse_known_args()
utils.import_user_module(usr_args)
parser = argparse.ArgumentParser(allow_abb... |
def add_preprocess_args(parser):
group = parser.add_argument_group('Preprocessing')
group.add_argument('-s', '--source-lang', default=None, metavar='SRC', help='source language')
group.add_argument('-t', '--target-lang', default=None, metavar='TARGET', help='target language')
group.add_argument('--tra... |
def add_dataset_args(parser, train=False, gen=False):
group = parser.add_argument_group('Dataset and data loading')
group.add_argument('--num-workers', default=1, type=int, metavar='N', help='how many subprocesses to use for data loading')
group.add_argument('--skip-invalid-size-inputs-valid-test', action... |
def add_distributed_training_args(parser):
group = parser.add_argument_group('Distributed training')
group.add_argument('--distributed-world-size', type=int, metavar='N', default=max(1, torch.cuda.device_count()), help='total number of GPUs across all nodes (default: all visible GPUs)')
group.add_argument... |
def add_optimization_args(parser):
group = parser.add_argument_group('Optimization')
group.add_argument('--max-epoch', '--me', default=0, type=int, metavar='N', help='force stop training at specified epoch')
group.add_argument('--max-update', '--mu', default=0, type=int, metavar='N', help='force stop trai... |
def add_checkpoint_args(parser):
group = parser.add_argument_group('Checkpointing')
group.add_argument('--save-dir', metavar='DIR', default='checkpoints', help='path to save checkpoints')
group.add_argument('--restore-file', default='checkpoint_last.pt', help='filename from which to load checkpoint (defau... |
def add_common_eval_args(group):
group.add_argument('--path', metavar='FILE', help='path(s) to model file(s), colon separated')
group.add_argument('--remove-bpe', nargs='?', const='@@ ', default=None, help='remove BPE tokens before scoring (can be set to sentencepiece)')
group.add_argument('--quiet', acti... |
def add_eval_lm_args(parser):
group = parser.add_argument_group('LM Evaluation')
add_common_eval_args(group)
group.add_argument('--output-word-probs', action='store_true', help='if set, outputs words and their predicted log probabilities to standard output')
group.add_argument('--output-word-stats', a... |
def add_generation_args(parser):
group = parser.add_argument_group('Generation')
add_common_eval_args(group)
group.add_argument('--beam', default=5, type=int, metavar='N', help='beam size')
group.add_argument('--nbest', default=1, type=int, metavar='N', help='number of hypotheses to output')
group... |
def add_interactive_args(parser):
group = parser.add_argument_group('Interactive')
group.add_argument('--buffer-size', default=0, type=int, metavar='N', help='read this many sentences into a buffer before processing them')
group.add_argument('--input', default='-', type=str, metavar='FILE', help='file to ... |
def add_model_args(parser):
group = parser.add_argument_group('Model configuration')
from fairseq.models import ARCH_MODEL_REGISTRY
group.add_argument('--arch', '-a', default='fconv', metavar='ARCH', choices=ARCH_MODEL_REGISTRY.keys(), help='Model Architecture')
return group
|
class MultiprocessingPdb(pdb.Pdb):
'A Pdb wrapper that works in a multiprocessing environment.\n\n Usage: `from fairseq import pdb; pdb.set_trace()`\n '
def __init__(self):
pdb.Pdb.__init__(self, nosigint=True)
def _cmdloop(self):
stdin_bak = sys.stdin
with _stdin_lock:
... |
def set_trace():
pdb = MultiprocessingPdb()
pdb.set_trace(sys._getframe().f_back)
|
def build_progress_bar(args, iterator, epoch=None, prefix=None, default='tqdm', no_progress_bar='none'):
if (args.log_format is None):
args.log_format = (no_progress_bar if args.no_progress_bar else default)
if ((args.log_format == 'tqdm') and (not sys.stderr.isatty())):
args.log_format = 'sim... |
def format_stat(stat):
if isinstance(stat, Number):
stat = '{:g}'.format(stat)
elif isinstance(stat, AverageMeter):
stat = '{:.3f}'.format(stat.avg)
elif isinstance(stat, TimeMeter):
stat = '{:g}'.format(round(stat.avg))
elif isinstance(stat, StopwatchMeter):
stat = '{:... |
class progress_bar(object):
'Abstract class for progress bars.'
def __init__(self, iterable, epoch=None, prefix=None):
self.iterable = iterable
self.offset = getattr(iterable, 'offset', 0)
self.epoch = epoch
self.prefix = ''
if (epoch is not None):
self.pre... |
@contextmanager
def rename_logger(logger, new_name):
old_name = logger.name
if (new_name is not None):
logger.name = new_name
(yield logger)
logger.name = old_name
|
class json_progress_bar(progress_bar):
'Log output in JSON format.'
def __init__(self, iterable, epoch=None, prefix=None, log_interval=1000):
super().__init__(iterable, epoch, prefix)
self.log_interval = log_interval
self.stats = None
self.tag = None
def __iter__(self):
... |
class noop_progress_bar(progress_bar):
'No logging.'
def __init__(self, iterable, epoch=None, prefix=None):
super().__init__(iterable, epoch, prefix)
def __iter__(self):
for obj in self.iterable:
(yield obj)
def log(self, stats, tag=None, step=None):
'Log interme... |
class simple_progress_bar(progress_bar):
'A minimal logger for non-TTY environments.'
def __init__(self, iterable, epoch=None, prefix=None, log_interval=1000):
super().__init__(iterable, epoch, prefix)
self.log_interval = log_interval
self.stats = None
self.tag = None
def... |
class tqdm_progress_bar(progress_bar):
'Log to tqdm.'
def __init__(self, iterable, epoch=None, prefix=None):
super().__init__(iterable, epoch, prefix)
from tqdm import tqdm
self.tqdm = tqdm(iterable, self.prefix, leave=False)
def __iter__(self):
return iter(self.tqdm)
... |
class tensorboard_log_wrapper(progress_bar):
'Log to tensorboard.'
def __init__(self, wrapped_bar, tensorboard_logdir, args):
self.wrapped_bar = wrapped_bar
self.tensorboard_logdir = tensorboard_logdir
self.args = args
try:
from tensorboardX import SummaryWriter
... |
def setup_registry(registry_name: str, base_class=None, default=None):
assert registry_name.startswith('--')
registry_name = registry_name[2:].replace('-', '_')
REGISTRY = {}
REGISTRY_CLASS_NAMES = set()
if (registry_name in REGISTRIES):
return
REGISTRIES[registry_name] = {'registry': ... |
def set_defaults(args, cls):
'Helper to set default arguments based on *add_args*.'
if (not hasattr(cls, 'add_args')):
return
parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS, allow_abbrev=False)
cls.add_args(parser)
defaults = argparse.Namespace()
for action in pars... |
def setup_task(args, **kwargs):
return TASK_REGISTRY[args.task].setup_task(args, **kwargs)
|
def register_task(name):
"\n New tasks can be added to fairseq with the\n :func:`~fairseq.tasks.register_task` function decorator.\n\n For example::\n\n @register_task('classification')\n class ClassificationTask(FairseqTask):\n (...)\n\n .. note::\n\n All Tasks must im... |
def get_task(name):
return TASK_REGISTRY[name]
|
@register_task('audio_pretraining')
class AudioPretrainingTask(FairseqTask):
'\n\n '
@staticmethod
def add_args(parser):
'Add task-specific arguments to the parser.'
parser.add_argument('data', help='path to data directory')
parser.add_argument('--sample-rate', default=16000, t... |
@register_task('cross_lingual_lm')
class CrossLingualLMTask(FairseqTask):
'\n Task for training cross-lingual language models.\n\n For more details look at: https://arxiv.org/pdf/1901.07291.pdf\n\n Args:\n dictionary (Dictionary): the dictionary for the input of the task\n '
@staticmethod
... |
@register_task('denoising')
class DenoisingTask(FairseqTask):
'\n Denoising task for applying sequence to sequence denoising. (ie. BART)\n '
@staticmethod
def add_args(parser):
'Add task-specific arguments to the parser.'
parser.add_argument('data', help='path to data directory')
... |
class FairseqTask(object):
'\n Tasks store dictionaries and provide helpers for loading/iterating over\n Datasets, initializing the Model/Criterion and calculating the loss.\n '
@staticmethod
def add_args(parser):
'Add task-specific arguments to the parser.'
pass
def __init_... |
@register_task('legacy_masked_lm')
class LegacyMaskedLMTask(FairseqTask):
'\n Task for training Masked LM (BERT) model.\n Args:\n dictionary (Dictionary): the dictionary for the input of the task\n '
@staticmethod
def add_args(parser):
'Add task-specific arguments to the parser.'
... |
@register_task('masked_lm')
class MaskedLMTask(FairseqTask):
'Task for training masked language models (e.g., BERT, RoBERTa).'
@staticmethod
def add_args(parser):
'Add task-specific arguments to the parser.'
parser.add_argument('data', help='colon separated path to data directories list, ... |
@register_task('multilingual_masked_lm')
class MultiLingualMaskedLMTask(FairseqTask):
'Task for training masked language models (e.g., BERT, RoBERTa).'
@staticmethod
def add_args(parser):
'Add task-specific arguments to the parser.'
parser.add_argument('data', help='colon separated path t... |
def _lang_token(lang: str):
return '__{}__'.format(lang)
|
def _lang_token_index(dic: Dictionary, lang: str):
'Return language token index.'
idx = dic.index(_lang_token(lang))
assert (idx != dic.unk_index), 'cannot find language token for lang {}'.format(lang)
return idx
|
@register_task('multilingual_translation')
class MultilingualTranslationTask(FairseqTask):
'A task for training multiple translation models simultaneously.\n\n We iterate round-robin over batches from multiple language pairs, ordered\n according to the `--lang-pairs` argument.\n\n The training loop is ro... |
def _get_bt_dataset_key(lang_pair):
return ('bt:' + lang_pair)
|
def _get_denoising_dataset_key(lang_pair):
return ('denoising:' + lang_pair)
|
def parse_lambda_config(x):
'\n Parse the configuration of lambda coefficient (for scheduling).\n x = "3" # lambda will be a constant equal to x\n x = "0:1,1000:0" # lambda will start from 1 and linearly decrease\n # to 0 during the first 1000 iteratio... |
@register_task('semisupervised_translation')
class SemisupervisedTranslationTask(MultilingualTranslationTask):
'A task for training multiple translation models simultaneously.\n\n We iterate round-robin over batches from multiple language pairs, ordered\n according to the `--lang-pairs` argument.\n\n The... |
@register_task('sentence_prediction')
class SentencePredictionTask(FairseqTask):
'\n Sentence (or sentence pair) prediction (classification or regression) task.\n\n Args:\n dictionary (Dictionary): the dictionary for the input of the task\n '
@staticmethod
def add_args(parser):
'A... |
@register_task('sentence_ranking')
class SentenceRankingTask(FairseqTask):
'\n Ranking task on multiple sentences.\n\n Args:\n dictionary (Dictionary): the dictionary for the input of the task\n '
@staticmethod
def add_args(parser):
'Add task-specific arguments to the parser.'
... |
def load_langpair_dataset(data_path, split, src, src_dict, tgt, tgt_dict, combine, dataset_impl, upsample_primary, left_pad_source, left_pad_target, max_source_positions, max_target_positions, prepend_bos=False, load_alignments=False, truncate_source=False):
def split_exists(split, src, tgt, lang, data_path):
... |
@register_task('translation')
class TranslationTask(FairseqTask):
'\n Translate from one (source) language to another (target) language.\n\n Args:\n src_dict (~fairseq.data.Dictionary): dictionary for the source language\n tgt_dict (~fairseq.data.Dictionary): dictionary for the target language... |
@register_task('translation_from_pretrained_xlm')
class TranslationFromPretrainedXLMTask(TranslationTask):
'\n Same as TranslationTask except use the MaskedLMDictionary class so that\n we can load data that was binarized with the MaskedLMDictionary class.\n\n This task should be used for the entire train... |
def tokenize_line(line):
line = SPACE_NORMALIZER.sub(' ', line)
line = line.strip()
return line.split()
|
class Trainer(object):
'Main class for data parallel training.\n\n This class supports synchronous distributed data parallel training,\n where multiple workers each have a full model replica and gradients\n are accumulated across workers before each update. We use\n :class:`~torch.nn.parallel.Distribu... |
class WordStat(object):
def __init__(self, word, is_bpe):
self.word = word
self.is_bpe = is_bpe
self.log_prob = 0
self.next_word_prob = 0
self.count = 0
self.missing_next_words = 0
def add(self, log_prob, next_word_prob):
' increments counters for the ... |
def main(parsed_args):
assert (parsed_args.path is not None), '--path required for evaluation!'
utils.import_user_module(parsed_args)
logger.info(parsed_args)
use_cuda = (torch.cuda.is_available() and (not parsed_args.cpu))
task = tasks.setup_task(parsed_args)
logger.info('loading model(s) fro... |
def cli_main():
parser = options.get_eval_lm_parser()
args = options.parse_args_and_arch(parser)
main(args)
|
def buffered_read(input, buffer_size):
buffer = []
with fileinput.input(files=[input], openhook=fileinput.hook_encoded('utf-8')) as h:
for src_str in h:
buffer.append(src_str.strip())
if (len(buffer) >= buffer_size):
(yield buffer)
buffer = []
... |
def make_batches(lines, args, task, max_positions, encode_fn):
tokens = [task.source_dictionary.encode_line(encode_fn(src_str), add_if_not_exist=False).long() for src_str in lines]
lengths = [t.numel() for t in tokens]
itr = task.get_batch_iterator(dataset=task.build_dataset_for_inference(tokens, lengths)... |
def main(args):
utils.import_user_module(args)
if (args.buffer_size < 1):
args.buffer_size = 1
if ((args.max_tokens is None) and (args.max_sentences is None)):
args.max_sentences = 1
assert ((not args.sampling) or (args.nbest == args.beam)), '--sampling requires --nbest to be equal to ... |
def cli_main():
parser = options.get_generation_parser(interactive=True)
args = options.parse_args_and_arch(parser)
main(args)
|
def main(args):
utils.import_user_module(args)
os.makedirs(args.destdir, exist_ok=True)
logger.addHandler(logging.FileHandler(filename=os.path.join(args.destdir, 'preprocess.log')))
logger.info(args)
task = tasks.get_task(args.task)
def train_path(lang):
return '{}{}'.format(args.trai... |
def binarize(args, filename, vocab, output_prefix, lang, offset, end, append_eos=True):
ds = indexed_dataset.make_builder(dataset_dest_file(args, output_prefix, lang, 'bin'), impl=args.dataset_impl, vocab_size=len(vocab))
def consumer(tensor):
ds.add_item(tensor)
res = Binarizer.binarize(filename... |
def binarize_alignments(args, filename, parse_alignment, output_prefix, offset, end):
ds = indexed_dataset.make_builder(dataset_dest_file(args, output_prefix, None, 'bin'), impl=args.dataset_impl, vocab_size=None)
def consumer(tensor):
ds.add_item(tensor)
res = Binarizer.binarize_alignments(filen... |
def dataset_dest_prefix(args, output_prefix, lang):
base = '{}/{}'.format(args.destdir, output_prefix)
if (lang is not None):
lang_part = '.{}-{}.{}'.format(args.source_lang, args.target_lang, lang)
elif args.only_source:
lang_part = ''
else:
lang_part = '.{}-{}'.format(args.so... |
def dataset_dest_file(args, output_prefix, lang, extension):
base = dataset_dest_prefix(args, output_prefix, lang)
return '{}.{}'.format(base, extension)
|
def get_offsets(input_file, num_workers):
return Binarizer.find_offsets(input_file, num_workers)
|
def cli_main():
parser = options.get_preprocessing_parser()
args = parser.parse_args()
main(args)
|
def get_parser():
parser = argparse.ArgumentParser(description='Command-line script for BLEU scoring.')
parser.add_argument('-s', '--sys', default='-', help='system output')
parser.add_argument('-r', '--ref', required=True, help='references')
parser.add_argument('-o', '--order', default=4, metavar='N'... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.