code stringlengths 17 6.64M |
|---|
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', required=True, 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)
|
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... |
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... |
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
def __iter__(self):
size = float(len(... |
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='', step=None):
'Log intermedi... |
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
def __iter__(self):
... |
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 For more details look at: https://arxiv.org/pdf/1901.07291.pdf\n Args:\n dictionary (Dictionary): the dictionary for the input of the task\n '
@staticmethod
... |
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('language_modeling')
class LanguageModelingTask(FairseqTask):
'\n Train a language model.\n\n Args:\n dictionary (~fairseq.data.Dictionary): the dictionary for the input of\n the language model\n output_dictionary (~fairseq.data.Dictionary): the dictionary for the\n ... |
@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):
def split_exists(split, src, tgt, lang, data_path):
filename = os.pat... |
@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)
print(parsed_args)
use_cuda = (torch.cuda.is_available() and (not parsed_args.cpu))
task = tasks.setup_task(parsed_args)
print('| loading model(s) from {}'.form... |
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 = torch.LongTensor([t.numel() for t in tokens])
itr = task.get_batch_iterator(dataset=task.build_dataset_for_inferenc... |
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)
print(args)
os.makedirs(args.destdir, exist_ok=True)
target = (not args.only_source)
task = tasks.get_task(args.task)
def train_path(lang):
return '{}{}'.format(args.trainpref, (('.' + lang) if lang else ''))
def file_name(prefix, la... |
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'... |
def main():
parser = get_parser()
args = parser.parse_args()
print(args)
assert ((args.sys == '-') or os.path.exists(args.sys)), 'System output file {} does not exist'.format(args.sys)
assert os.path.exists(args.ref), 'Reference file {} does not exist'.format(args.ref)
dict = dictionary.Dictio... |
class NumpyExtension(Extension):
'Source: https://stackoverflow.com/a/54128391'
def __init__(self, *args, **kwargs):
self.__include_dirs = []
super().__init__(*args, **kwargs)
@property
def include_dirs(self):
import numpy
return (self.__include_dirs + [numpy.get_incl... |
def main(args, init_distributed=False):
utils.import_user_module(args)
try:
from fairseq.fb_pathmgr import fb_pathmgr
global fb_pathmgr_registerd
if (not fb_pathmgr_registerd):
fb_pathmgr.register()
fb_pathmgr_registerd = True
except (ModuleNotFoundError, Im... |
def train(args, trainer, task, epoch_itr):
'Train the model for one epoch.'
update_freq = (args.update_freq[(epoch_itr.epoch - 1)] if (epoch_itr.epoch <= len(args.update_freq)) else args.update_freq[(- 1)])
itr = epoch_itr.next_epoch_itr(fix_batches_to_gpus=args.fix_batches_to_gpus, shuffle=(epoch_itr.epo... |
def get_training_stats(trainer):
stats = collections.OrderedDict()
stats['loss'] = trainer.get_meter('train_loss')
if (trainer.get_meter('train_nll_loss').count > 0):
nll_loss = trainer.get_meter('train_nll_loss')
stats['nll_loss'] = nll_loss
else:
nll_loss = trainer.get_meter(... |
def validate(args, trainer, task, epoch_itr, subsets):
'Evaluate the model on the validation set(s) and return the losses.'
if (args.fixed_validation_seed is not None):
utils.set_torch_seed(args.fixed_validation_seed)
valid_losses = []
for subset in subsets:
itr = task.get_batch_iterat... |
def get_valid_stats(trainer, args, extra_meters=None):
stats = collections.OrderedDict()
stats['loss'] = trainer.get_meter('valid_loss')
if (trainer.get_meter('valid_nll_loss').count > 0):
nll_loss = trainer.get_meter('valid_nll_loss')
stats['nll_loss'] = nll_loss
else:
nll_los... |
def distributed_main(i, args, start_rank=0):
args.device_id = i
if (args.distributed_rank is None):
args.distributed_rank = (start_rank + i)
main(args, init_distributed=True)
|
def cli_main():
parser = options.get_training_parser()
args = options.parse_args_and_arch(parser)
if (args.distributed_init_method is None):
distributed_utils.infer_init_method(args)
if (args.distributed_init_method is not None):
if ((torch.cuda.device_count() > 1) and (not args.distri... |
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 = torch.LongTensor([t.numel() for t in tokens])
itr = task.get_batch_iterator(dataset=task.build_dataset_for_inferenc... |
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)
print(args)
os.makedirs(args.destdir, exist_ok=True)
target = (not args.only_source)
task = tasks.get_task(args.task)
def train_path(lang):
return '{}{}'.format(args.trainpref, (('.' + lang) if lang else ''))
def file_name(prefix, la... |
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'... |
def main():
parser = get_parser()
args = parser.parse_args()
print(args)
assert ((args.sys == '-') or os.path.exists(args.sys)), 'System output file {} does not exist'.format(args.sys)
assert os.path.exists(args.ref), 'Reference file {} does not exist'.format(args.ref)
dict = dictionary.Dictio... |
def average_checkpoints(inputs):
"Loads checkpoints from inputs and returns a model with averaged weights.\n\n Args:\n inputs: An iterable of string paths of checkpoints to load from.\n\n Returns:\n A dict of string keys mapping to various values. The 'model' key\n from the returned dict shou... |
def last_n_checkpoints(paths, n, update_based, upper_bound=None):
assert (len(paths) == 1)
path = paths[0]
if update_based:
pt_regexp = re.compile('checkpoint_\\d+_(\\d+)\\.pt')
else:
pt_regexp = re.compile('checkpoint(\\d+)\\.pt')
files = os.listdir(path)
entries = []
for ... |
def main():
parser = argparse.ArgumentParser(description='Tool to average the params of input checkpoints to produce a new checkpoint')
parser.add_argument('--inputs', required=True, nargs='+', help='Input checkpoint file paths.')
parser.add_argument('--output', required=True, metavar='FILE', help='Write ... |
class NumpyExtension(Extension):
'Source: https://stackoverflow.com/a/54128391'
def __init__(self, *args, **kwargs):
self.__include_dirs = []
super().__init__(*args, **kwargs)
@property
def include_dirs(self):
import numpy
return (self.__include_dirs + [numpy.get_incl... |
def main(args, init_distributed=False):
utils.import_user_module(args)
try:
from fairseq.fb_pathmgr import fb_pathmgr
global fb_pathmgr_registerd
if (not fb_pathmgr_registerd):
fb_pathmgr.register()
fb_pathmgr_registerd = True
except (ModuleNotFoundError, Im... |
def train(args, trainer, task, epoch_itr):
'Train the model for one epoch.'
update_freq = (args.update_freq[(epoch_itr.epoch - 1)] if (epoch_itr.epoch <= len(args.update_freq)) else args.update_freq[(- 1)])
itr = epoch_itr.next_epoch_itr(fix_batches_to_gpus=args.fix_batches_to_gpus, shuffle=(epoch_itr.epo... |
def get_training_stats(trainer):
stats = collections.OrderedDict()
stats['loss'] = trainer.get_meter('train_loss')
if (trainer.get_meter('train_nll_loss').count > 0):
nll_loss = trainer.get_meter('train_nll_loss')
stats['nll_loss'] = nll_loss
else:
nll_loss = trainer.get_meter(... |
def validate(args, trainer, task, epoch_itr, subsets):
'Evaluate the model on the validation set(s) and return the losses.'
if (args.fixed_validation_seed is not None):
utils.set_torch_seed(args.fixed_validation_seed)
valid_losses = []
for subset in subsets:
itr = task.get_batch_iterat... |
def get_valid_stats(trainer, args, extra_meters=None):
stats = collections.OrderedDict()
stats['loss'] = trainer.get_meter('valid_loss')
if (trainer.get_meter('valid_nll_loss').count > 0):
nll_loss = trainer.get_meter('valid_nll_loss')
stats['nll_loss'] = nll_loss
else:
nll_los... |
def distributed_main(i, args, start_rank=0):
args.device_id = i
if (args.distributed_rank is None):
args.distributed_rank = (start_rank + i)
main(args, init_distributed=True)
|
def cli_main():
parser = options.get_training_parser()
args = options.parse_args_and_arch(parser)
if (args.distributed_init_method is None):
distributed_utils.infer_init_method(args)
if (args.distributed_init_method is not None):
if ((torch.cuda.device_count() > 1) and (not args.distri... |
def main(args, override_args=None):
utils.import_user_module(args)
use_fp16 = args.fp16
use_cuda = (torch.cuda.is_available() and (not args.cpu))
if (override_args is not None):
overrides = vars(override_args)
overrides.update(eval(getattr(override_args, 'model_overrides', '{}')))
... |
def cli_main():
parser = options.get_validation_parser()
args = options.parse_args_and_arch(parser)
override_parser = options.get_validation_parser()
override_args = options.parse_args_and_arch(override_parser, suppress_defaults=True)
main(args, override_args)
|
@lru_cache()
def default_bpe():
return os.path.join(os.path.dirname(os.path.abspath(__file__)), 'bpe_simple_vocab_16e6.txt.gz')
|
@lru_cache()
def bytes_to_unicode():
"\n Returns list of utf-8 byte and a corresponding list of unicode strings.\n The reversible bpe codes work on unicode strings.\n This means you need a large # of unicode characters in your vocab if you want to avoid UNKs.\n When you're at something like a 10B toke... |
def get_pairs(word):
'Return set of symbol pairs in a word.\n Word is represented as tuple of symbols (symbols being variable-length strings).\n '
pairs = set()
prev_char = word[0]
for char in word[1:]:
pairs.add((prev_char, char))
prev_char = char
return pairs
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.