code stringlengths 17 6.64M |
|---|
def cli_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.Di... |
def main(args, init_distributed=False):
utils.import_user_module(args)
assert ((args.max_tokens is not None) or (args.max_sentences is not None)), 'Must specify batch size either with --max-tokens or --max-sentences'
if (torch.cuda.is_available() and (not args.cpu)):
torch.cuda.set_device(args.dev... |
def should_stop_early(args, valid_loss):
if (args.patience <= 0):
return False
def is_better(a, b):
return ((a > b) if args.maximize_best_checkpoint_metric else (a < b))
prev_best = getattr(should_stop_early, 'best', None)
if ((prev_best is None) or is_better(valid_loss, prev_best)):
... |
@metrics.aggregate('train')
def train(args, trainer, task, epoch_itr):
'Train the model for one epoch.'
itr = epoch_itr.next_epoch_itr(fix_batches_to_gpus=args.fix_batches_to_gpus, shuffle=(epoch_itr.epoch >= args.curriculum))
update_freq = (args.update_freq[(epoch_itr.epoch - 1)] if (epoch_itr.epoch <= l... |
def get_training_stats(stats):
if (('nll_loss' in stats) and ('ppl' not in stats)):
stats['ppl'] = utils.get_perplexity(stats['nll_loss'])
stats['wall'] = round(metrics.get_meter('default', 'wall').elapsed_time, 0)
return stats
|
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(args, trainer, stats):
if (('nll_loss' in stats) and ('ppl' not in stats)):
stats['ppl'] = utils.get_perplexity(stats['nll_loss'])
stats['num_updates'] = trainer.get_num_updates()
if hasattr(checkpoint_utils.save_checkpoint, 'best'):
key = 'best_{0}'.format(args.best_ch... |
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(modify_parser=None):
parser = options.get_training_parser()
args = options.parse_args_and_arch(parser, modify_parser=modify_parser)
if (args.distributed_init_method is None):
distributed_utils.infer_init_method(args)
if (args.distributed_init_method is not None):
if ((torc... |
def main(args, override_args=None):
utils.import_user_module(args)
assert ((args.max_tokens is not None) or (args.max_sentences is not None)), 'Must specify batch size either with --max-tokens or --max-sentences'
use_fp16 = args.fp16
use_cuda = (torch.cuda.is_available() and (not args.cpu))
if (ov... |
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)
|
def run_experiment(args):
max_update = args.max_updates
warmup_update = args.warmup_updates
lr_period_updates = (max_update - warmup_update)
max_tokens = args.max_tokens
tokens_per_sample = args.tokens_per_sample
update_freq = args.update_freq
num_gpus = args.num_gpus
data_dir = args.d... |
def run_experiment(args):
max_update = args.max_updates
warmup_update = args.warmup_updates
lr_period_updates = (max_update - warmup_update)
max_tokens = args.max_tokens
update_freq = args.update_freq
num_gpus = args.num_gpus
data_dir = args.data_dir
results_dir = args.save_dir
d_m... |
def run_experiment(args):
max_update = args.max_updates
warmup_update = args.warmup_updates
lr_period_updates = 70000
max_tokens = args.max_tokens
update_freq = args.update_freq
num_gpus = args.num_gpus
data_dir = args.data_dir
results_dir = args.save_dir
d_m = args.d_m
if (d_m... |
def run_experiment(args):
max_update = args.max_updates
warmup_update = args.warmup_updates
max_tokens = args.max_tokens
update_freq = args.update_freq
num_gpus = args.num_gpus
data_dir = args.data_dir
results_dir = args.save_dir
d_m = args.d_m
if (d_m not in TESTED_DIMS):
... |
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 ... |
def main():
parser = argparse.ArgumentParser(description='symmetric alignment builer')
parser.add_argument('--fast_align_dir', help='path to fast_align build directory')
parser.add_argument('--mosesdecoder_dir', help='path to mosesdecoder root directory')
parser.add_argument('--sym_heuristic', help='h... |
def main():
ns1 = eval(input('Namespace 1: '))
ns2 = eval(input('Namespace 2: '))
def keys(ns):
ks = set()
for k in dir(ns):
if (not k.startswith('_')):
ks.add(k)
return ks
k1 = keys(ns1)
k2 = keys(ns2)
def print_keys(ks, ns1, ns2=None):
... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('input')
parser.add_argument('--gzip', action='store_true')
args = parser.parse_args()
def gopen():
if args.gzip:
return gzip.open(args.input, 'r')
else:
return open(args.input, 'r', encodin... |
def get_parser():
parser = argparse.ArgumentParser(description='writes text from binarized file to stdout')
parser.add_argument('--dataset-impl', help='dataset implementation', choices=indexed_dataset.get_available_dataset_impl())
parser.add_argument('--dict', metavar='FP', help='dictionary containing kno... |
def main():
parser = get_parser()
args = parser.parse_args()
dictionary = (Dictionary.load(args.dict) if (args.dict is not None) else None)
dataset = data_utils.load_indexed_dataset(args.input, dictionary, dataset_impl=args.dataset_impl, default='lazy')
for tensor_line in dataset:
if (dict... |
def parse_checkpoints(files):
entries = []
for f in files:
m = pt_regexp_epoch_based.fullmatch(f)
if (m is not None):
entries.append((int(m.group(1)), m.group(0)))
else:
m = pt_regexp_update_based.fullmatch(f)
if (m is not None):
entr... |
def last_n_checkpoints(files, n):
entries = parse_checkpoints(files)
return [x[1] for x in sorted(entries, reverse=True)[:n]]
|
def every_n_checkpoints(files, n):
entries = parse_checkpoints(files)
return [x[1] for x in sorted(sorted(entries)[::(- n)])]
|
def main():
parser = argparse.ArgumentParser(description='Recursively delete checkpoint files from `root_dir`, but preserve checkpoint_best.pt and checkpoint_last.pt')
parser.add_argument('root_dirs', nargs='*')
parser.add_argument('--save-last', type=int, default=0, help='number of last checkpoints to sa... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('input')
parser.add_argument('--num-shards', type=int)
args = parser.parse_args()
assert ((args.num_shards is not None) and (args.num_shards > 1))
with open(args.input, 'r', encoding='utf-8') as h:
with contextlib.ExitS... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('input')
parser.add_argument('sample_output', help='train output file')
parser.add_argument('remainder_output', help='valid output file')
parser.add_argument('-k', type=int, help='remainder size')
parser.add_argument('--lines',... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model', required=True, help='sentencepiece model to use for decoding')
parser.add_argument('--input', required=True, help='input file to decode')
parser.add_argument('--input_format', choices=['piece', 'id'], default='piece')
ar... |
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model', required=True, help='sentencepiece model to use for encoding')
parser.add_argument('--inputs', nargs='+', default=['-'], help='input files to filter/encode')
parser.add_argument('--outputs', nargs='+', default=['-'], help='p... |
def read_audio(fname):
' Load an audio file and return PCM along with the sample rate '
(wav, sr) = sf.read(fname)
assert (sr == 16000.0)
return (wav, 16000.0)
|
class PretrainedWav2VecModel(nn.Module):
def __init__(self, fname):
super().__init__()
checkpoint = torch.load(fname)
self.args = checkpoint['args']
model = Wav2VecModel.build_model(self.args, None)
model.load_state_dict(checkpoint['model'])
model.eval()
se... |
class EmbeddingWriterConfig(argparse.ArgumentParser):
def __init__(self):
super().__init__('Pre-compute embeddings for wav2letter++ datasets')
kwargs = {'action': 'store', 'type': str, 'required': True}
self.add_argument('--input', '-i', help='Input Directory', **kwargs)
self.add_... |
class Prediction():
' Lightweight wrapper around a fairspeech embedding model '
def __init__(self, fname, gpu=0):
self.gpu = gpu
self.model = PretrainedWav2VecModel(fname).cuda(gpu)
def __call__(self, x):
x = torch.from_numpy(x).float().cuda(self.gpu)
with torch.no_grad()... |
class H5Writer():
' Write features as hdf5 file in wav2letter++ compatible format '
def __init__(self, fname):
self.fname = fname
os.makedirs(os.path.dirname(self.fname), exist_ok=True)
def write(self, data):
(channel, T) = data.shape
with h5py.File(self.fname, 'w') as ou... |
class EmbeddingDatasetWriter(object):
' Given a model and a wav2letter++ dataset, pre-compute and store embeddings\n\n Args:\n input_root, str :\n Path to the wav2letter++ dataset\n output_root, str :\n Desired output directory. Will be created if non-existent\n split... |
def get_parser():
parser = argparse.ArgumentParser()
parser.add_argument('root', metavar='DIR', help='root directory containing flac files to index')
parser.add_argument('--valid-percent', default=0.01, type=float, metavar='D', help='percentage of data to use as validation set (between 0 and 1)')
pars... |
def main(args):
assert ((args.valid_percent >= 0) and (args.valid_percent <= 1.0))
dir_path = os.path.realpath(args.root)
search_path = os.path.join(dir_path, ('**/*.' + args.ext))
rand = random.Random(args.seed)
with open(os.path.join(args.dest, 'train.tsv'), 'w') as train_f, open(os.path.join(ar... |
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 get_dummy_dictionary(vocab_size=DEFAULT_TEST_VOCAB_SIZE):
dummy_dict = Dictionary()
for (id, _) in enumerate(range(vocab_size)):
dummy_dict.add_symbol('{}'.format(id), 1000)
return dummy_dict
|
class DummyTask(FairseqTask):
def __init__(self, args):
super().__init__(args)
self.dictionary = get_dummy_dictionary()
if getattr(self.args, 'ctc', False):
self.dictionary.add_symbol('<ctc_blank>')
self.tgt_dict = self.dictionary
@property
def target_dictiona... |
def get_dummy_task_and_parser():
'\n to build a fariseq model, we need some dummy parse and task. This function\n is used to create dummy task and parser to faciliate model/criterion test\n\n Note: we use FbSpeechRecognitionTask as the dummy task. You may want\n to use other task by providing another ... |
def get_dummy_input(T=100, D=80, B=5, K=100):
forward_input = {}
feature = torch.randn(B, T, D)
src_lengths = torch.from_numpy(np.random.randint(low=1, high=T, size=B, dtype=np.int64))
src_lengths[0] = T
prev_output_tokens = []
for b in range(B):
token_length = np.random.randint(low=1,... |
def get_dummy_encoder_output(encoder_out_shape=(100, 80, 5)):
'\n This only provides an example to generate dummy encoder output\n '
(T, B, D) = encoder_out_shape
encoder_out = {}
encoder_out['encoder_out'] = torch.from_numpy(np.random.randn(*encoder_out_shape).astype(np.float32))
seq_length... |
def _current_postion_info():
cf = currentframe()
frameinfo = ' (at {}:{})'.format(os.path.basename(getframeinfo(cf).filename), cf.f_back.f_lineno)
return frameinfo
|
def check_encoder_output(encoder_output, batch_size=None):
'we expect encoder_output to be a dict with the following\n key/value pairs:\n - encoder_out: a Torch.Tensor\n - encoder_padding_mask: a binary Torch.Tensor\n '
if (not isinstance(encoder_output, dict)):
msg = ('FairseqEncoderModel... |
def check_decoder_output(decoder_output):
'we expect output from a decoder is a tuple with the following constraint:\n - the first element is a torch.Tensor\n - the second element can be anything (reserved for future use)\n '
if (not isinstance(decoder_output, tuple)):
msg = ('FariseqDecoder ... |
class TestBaseFairseqModelBase(unittest.TestCase):
'\n This class is used to facilitate writing unittest for any class derived from\n `BaseFairseqModel`.\n '
@classmethod
def setUpClass(cls):
if (cls is TestBaseFairseqModelBase):
raise unittest.SkipTest('Skipping test case in... |
class TestFairseqEncoderDecoderModelBase(TestBaseFairseqModelBase):
'\n base code to test FairseqEncoderDecoderModel (formally known as\n `FairseqModel`) must be derived from this base class\n '
@classmethod
def setUpClass(cls):
if (cls is TestFairseqEncoderDecoderModelBase):
... |
class TestFairseqEncoderModelBase(TestBaseFairseqModelBase):
'\n base class to test FairseqEncoderModel\n '
@classmethod
def setUpClass(cls):
if (cls is TestFairseqEncoderModelBase):
raise unittest.SkipTest('Skipping test case in base')
super().setUpClass()
def setU... |
class TestFairseqEncoderBase(unittest.TestCase):
'\n base class to test FairseqEncoder\n '
@classmethod
def setUpClass(cls):
if (cls is TestFairseqEncoderBase):
raise unittest.SkipTest('Skipping test case in base')
super().setUpClass()
def setUpEncoder(self, encoder... |
class TestFairseqDecoderBase(unittest.TestCase):
'\n base class to test FairseqDecoder\n '
@classmethod
def setUpClass(cls):
if (cls is TestFairseqDecoderBase):
raise unittest.SkipTest('Skipping test case in base')
super().setUpClass()
def setUpDecoder(self, decoder... |
class DummyEncoderModel(FairseqEncoderModel):
def __init__(self, encoder):
super().__init__(encoder)
@classmethod
def build_model(cls, args, task):
return cls(DummyEncoder())
def get_logits(self, net_output):
return torch.log(torch.div(net_output['encoder_out'], (1 - net_out... |
class DummyEncoder(FairseqEncoder):
def __init__(self):
super().__init__(None)
def forward(self, src_tokens, src_lengths):
(mask, max_len) = lengths_to_encoder_padding_mask(src_lengths)
return {'encoder_out': src_tokens, 'encoder_padding_mask': mask}
|
class CrossEntropyCriterionTestBase(unittest.TestCase):
@classmethod
def setUpClass(cls):
if (cls is CrossEntropyCriterionTestBase):
raise unittest.SkipTest('Skipping base class test case')
super().setUpClass()
def setUpArgs(self):
args = argparse.Namespace()
... |
class TestSeq2SeqCollator(unittest.TestCase):
def test_collate(self):
eos_idx = 1
pad_idx = 0
collater = Seq2SeqCollater(feature_index=0, label_index=1, pad_index=pad_idx, eos_index=eos_idx)
frames1 = np.array([[7, 8], [9, 10]])
frames2 = np.array([[1, 2], [3, 4], [5, 6]])... |
class CrossEntropyWithAccCriterionTest(CrossEntropyCriterionTestBase):
def setUp(self):
self.criterion_cls = CrossEntropyWithAccCriterion
super().setUp()
def test_cross_entropy_all_correct(self):
sample = self.get_test_sample(correct=True, soft_target=False, aggregate=False)
... |
class VGGTransformerModelTest_mid(TestFairseqEncoderDecoderModelBase):
def setUp(self):
def override_config(args):
'\n vggtrasformer_1 use 14 layers of transformer,\n for testing purpose, it is too expensive. For fast turn-around\n test, reduce the number of ... |
class VGGTransformerModelTest_big(TestFairseqEncoderDecoderModelBase):
def setUp(self):
def override_config(args):
'\n vggtrasformer_2 use 16 layers of transformer,\n for testing purpose, it is too expensive. For fast turn-around\n test, reduce the number of ... |
class VGGTransformerModelTest_base(TestFairseqEncoderDecoderModelBase):
def setUp(self):
def override_config(args):
'\n vggtrasformer_base use 12 layers of transformer,\n for testing purpose, it is too expensive. For fast turn-around\n test, reduce the number... |
class VGGTransformerEncoderTest(TestFairseqEncoderBase):
def setUp(self):
super().setUp()
self.setUpInput(get_dummy_input(T=50, D=80, B=5))
def test_forward(self):
print('1. test standard vggtransformer')
self.setUpEncoder(VGGTransformerEncoder(input_feat_per_channel=80))
... |
class TransformerDecoderTest(TestFairseqDecoderBase):
def setUp(self):
super().setUp()
dict = get_dummy_dictionary(vocab_size=DEFAULT_TEST_VOCAB_SIZE)
decoder = TransformerDecoder(dict)
dummy_encoder_output = get_dummy_encoder_output(encoder_out_shape=(50, 5, 256))
self.se... |
class ModelWithSharedParameter(nn.Module):
def __init__(self):
super(ModelWithSharedParameter, self).__init__()
self.embedding = nn.Embedding(1000, 200)
self.FC1 = nn.Linear(200, 200)
self.FC2 = nn.Linear(200, 200)
self.FC2.weight = nn.Parameter(self.FC1.weight)
se... |
class TestAverageCheckpoints(unittest.TestCase):
def test_average_checkpoints(self):
params_0 = collections.OrderedDict([('a', torch.DoubleTensor([100.0])), ('b', torch.FloatTensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])), ('c', torch.IntTensor([7, 8, 9]))])
params_1 = collections.OrderedDict([('a', ... |
class TestTranslation(unittest.TestCase):
def setUp(self):
logging.disable(logging.CRITICAL)
def tearDown(self):
logging.disable(logging.NOTSET)
def test_fconv(self):
with contextlib.redirect_stdout(StringIO()):
with tempfile.TemporaryDirectory('test_fconv') as data_... |
class TestStories(unittest.TestCase):
def setUp(self):
logging.disable(logging.CRITICAL)
def tearDown(self):
logging.disable(logging.NOTSET)
def test_fconv_self_att_wp(self):
with contextlib.redirect_stdout(StringIO()):
with tempfile.TemporaryDirectory('test_fconv_se... |
class TestLanguageModeling(unittest.TestCase):
def setUp(self):
logging.disable(logging.CRITICAL)
def tearDown(self):
logging.disable(logging.NOTSET)
def test_fconv_lm(self):
with contextlib.redirect_stdout(StringIO()):
with tempfile.TemporaryDirectory('test_fconv_lm... |
class TestMaskedLanguageModel(unittest.TestCase):
def setUp(self):
logging.disable(logging.CRITICAL)
def tearDown(self):
logging.disable(logging.NOTSET)
def test_legacy_masked_lm(self):
with contextlib.redirect_stdout(StringIO()):
with tempfile.TemporaryDirectory('te... |
def train_legacy_masked_language_model(data_dir, arch, extra_args=()):
train_parser = options.get_training_parser()
train_args = options.parse_args_and_arch(train_parser, (['--task', 'cross_lingual_lm', data_dir, '--arch', arch, '--optimizer', 'adam', '--lr-scheduler', 'reduce_lr_on_plateau', '--lr-shrink', '... |
class TestOptimizers(unittest.TestCase):
def setUp(self):
logging.disable(logging.CRITICAL)
def tearDown(self):
logging.disable(logging.NOTSET)
def test_optimizers(self):
with contextlib.redirect_stdout(StringIO()):
with tempfile.TemporaryDirectory('test_optimizers')... |
def create_dummy_data(data_dir, num_examples=100, maxlen=20, alignment=False):
def _create_dummy_data(filename):
data = torch.rand((num_examples * maxlen))
data = (97 + torch.floor((26 * data)).int())
with open(os.path.join(data_dir, filename), 'w') as h:
offset = 0
... |
def preprocess_translation_data(data_dir, extra_flags=None):
preprocess_parser = options.get_preprocessing_parser()
preprocess_args = preprocess_parser.parse_args((['--source-lang', 'in', '--target-lang', 'out', '--trainpref', os.path.join(data_dir, 'train'), '--validpref', os.path.join(data_dir, 'valid'), '-... |
def train_translation_model(data_dir, arch, extra_flags=None, task='translation', run_validation=False, lang_flags=None, extra_valid_flags=None):
if (lang_flags is None):
lang_flags = ['--source-lang', 'in', '--target-lang', 'out']
train_parser = options.get_training_parser()
train_args = options.... |
def generate_main(data_dir, extra_flags=None):
if (extra_flags is None):
extra_flags = ['--print-alignment']
generate_parser = options.get_generation_parser()
generate_args = options.parse_args_and_arch(generate_parser, ([data_dir, '--path', os.path.join(data_dir, 'checkpoint_last.pt'), '--beam', ... |
def preprocess_lm_data(data_dir):
preprocess_parser = options.get_preprocessing_parser()
preprocess_args = preprocess_parser.parse_args(['--only-source', '--trainpref', os.path.join(data_dir, 'train.out'), '--validpref', os.path.join(data_dir, 'valid.out'), '--testpref', os.path.join(data_dir, 'test.out'), '-... |
def train_language_model(data_dir, arch, extra_flags=None, run_validation=False):
train_parser = options.get_training_parser()
train_args = options.parse_args_and_arch(train_parser, (['--task', 'language_modeling', data_dir, '--arch', arch, '--optimizer', 'adam', '--lr', '0.0001', '--criterion', 'adaptive_los... |
def eval_lm_main(data_dir):
eval_lm_parser = options.get_eval_lm_parser()
eval_lm_args = options.parse_args_and_arch(eval_lm_parser, [data_dir, '--path', os.path.join(data_dir, 'checkpoint_last.pt'), '--no-progress-bar'])
eval_lm.main(eval_lm_args)
|
def train_masked_language_model(data_dir, arch, extra_args=()):
train_parser = options.get_training_parser()
train_args = options.parse_args_and_arch(train_parser, (['--task', 'cross_lingual_lm', data_dir, '--arch', arch, '--optimizer', 'adam', '--lr-scheduler', 'reduce_lr_on_plateau', '--lr-shrink', '0.5', '... |
class Model(nn.Module):
def __init__(self, input_size, output_size):
super(Model, self).__init__()
self.fc = nn.Linear(input_size, output_size)
def forward(self, input):
output = self.fc(input)
return output
|
def setup_model_loss_criterion(args, rank, is_cuda):
'\n setup model, criterion and optimizer based on input args\n '
args.distributed_rank = rank
distributed_utils.distributed_init(args)
torch.manual_seed(1)
model = Model(args.input_size, args.nb_classes)
loss_fn = nn.CrossEntropyLoss()... |
def train_step(input, target, model, loss_fn, optimizer):
'Do forward, backward and parameter update.'
model.train()
output = model(input)
loss = loss_fn(output, target)
optimizer.backward(loss)
optimizer.step()
|
def single_gpu_training(args, rank, iterations, shared_results):
is_cuda = torch.cuda.is_available()
if is_cuda:
torch.cuda.set_device(rank)
(model, loss_fn, optimizer) = setup_model_loss_criterion(args, rank, is_cuda)
for _ in range(iterations):
input = torch.randn(1, args.input_size)... |
def setup_args():
args = argparse.Namespace()
args.global_sync_iter = 20
args.block_momentum = 0.875
args.block_lr = 0.5
args.input_size = 5
args.nb_classes = 2
args.batch_size = 1
args.lr = [0.001]
args.momentum = 0
args.weight_decay = 0
args.warmup_iterations = 0
args... |
@unittest.skipIf((torch.cuda.device_count() < 2), 'test requires 2 GPUs')
class TestBMUF(unittest.TestCase):
def bmuf_process(self, args, iterations):
processes = []
results = Manager().dict()
ctx = torch.multiprocessing.get_context('spawn')
for rank in range(args.distributed_worl... |
class TestCharacterTokenEmbedder(unittest.TestCase):
def test_character_token_embedder(self):
vocab = Dictionary()
vocab.add_symbol('hello')
vocab.add_symbol('there')
embedder = CharacterTokenEmbedder(vocab, [(2, 16), (4, 32), (8, 64), (16, 2)], 64, 5, 2)
test_sents = [['h... |
class TestConcatDataset(unittest.TestCase):
def setUp(self):
d = mock_dict()
tokens_1 = torch.LongTensor([1]).view(1, (- 1))
tokens_ds1 = TokenBlockDataset(tokens_1, sizes=[tokens_1.size((- 1))], block_size=1, pad=0, eos=1, include_targets=False)
self.dataset_1 = LanguagePairDatas... |
class TestConvTBC(unittest.TestCase):
def test_convtbc(self):
conv_tbc = ConvTBC(4, 5, kernel_size=3, padding=1)
conv1d = nn.Conv1d(4, 5, kernel_size=3, padding=1)
conv_tbc.weight.data.copy_(conv1d.weight.data.transpose(0, 2))
conv_tbc.bias.data.copy_(conv1d.bias.data)
inp... |
class TestDictionary(unittest.TestCase):
def test_finalize(self):
txt = ['A B C D', 'B C D', 'C D', 'D']
ref_ids1 = list(map(torch.IntTensor, [[4, 5, 6, 7, 2], [5, 6, 7, 2], [6, 7, 2], [7, 2]]))
ref_ids2 = list(map(torch.IntTensor, [[7, 6, 5, 4, 2], [6, 5, 4, 2], [5, 4, 2], [4, 2]]))
... |
class DummyTask(FairseqTask):
def __init__(self, args):
super().__init__(args)
self.dictionary = get_dummy_dictionary()
if getattr(self.args, 'ctc', False):
self.dictionary.add_symbol('<ctc_blank>')
self.src_dict = self.dictionary
self.tgt_dict = self.dictionar... |
def get_dummy_dictionary(vocab_size=DEFAULT_TEST_VOCAB_SIZE):
dummy_dict = Dictionary()
for (id, _) in enumerate(range(vocab_size)):
dummy_dict.add_symbol('{}'.format(id), 1000)
return dummy_dict
|
def get_dummy_task_and_parser():
'\n Return a dummy task and argument parser, which can be used to\n create a model/criterion.\n '
parser = argparse.ArgumentParser(description='test_dummy_s2s_task', argument_default=argparse.SUPPRESS)
DummyTask.add_args(parser)
args = parser.parse_args([])
... |
class TestExportModels(unittest.TestCase):
def _test_save_and_load(self, scripted_module):
with tempfile.NamedTemporaryFile() as f:
scripted_module.save(f.name)
torch.jit.load(f.name)
def test_export_multihead_attention(self):
module = multihead_attention.MultiheadAtt... |
class TestFileIO(unittest.TestCase):
_tmpdir: Optional[str] = None
_tmpfile: Optional[str] = None
_tmpfile_contents = 'Hello, World'
@classmethod
def setUpClass(cls) -> None:
cls._tmpdir = tempfile.mkdtemp()
with open(os.path.join(cls._tmpdir, 'test.txt'), 'w') as f:
c... |
class TestIterators(unittest.TestCase):
def test_counting_iterator(self):
x = list(range(10))
itr = iterators.CountingIterator(x)
self.assertTrue(itr.has_next())
self.assertEqual(next(itr), 0)
self.assertEqual(next(itr), 1)
itr.skip(3)
self.assertEqual(next... |
@unittest.skipIf((not torch.cuda.is_available()), 'test requires a GPU')
class TestMemoryEfficientFP16(unittest.TestCase):
def setUp(self):
logging.disable(logging.CRITICAL)
def tearDown(self):
logging.disable(logging.NOTSET)
def test_load_state_dict(self):
model = torch.nn.Line... |
class TestMetrics(unittest.TestCase):
def test_nesting(self):
with metrics.aggregate() as a:
metrics.log_scalar('loss', 1)
with metrics.aggregate() as b:
metrics.log_scalar('loss', 2)
self.assertEqual(a.get_smoothed_values()['loss'], 1.5)
self.asser... |
class TestMultiCorpusSampledDataset(unittest.TestCase):
def setUp(self):
d = mock_dict()
tokens_1 = torch.LongTensor([1]).view(1, (- 1))
tokens_ds1 = TokenBlockDataset(tokens_1, sizes=[tokens_1.size((- 1))], block_size=1, pad=0, eos=1, include_targets=False)
self.dataset_1 = Langu... |
class TestMultiheadAttention(unittest.TestCase):
def test_append_prev_key_padding_mask(self):
bsz = 1
src_len = 4
cases = [(None, None, None), (torch.tensor([[1]]).bool(), None, torch.tensor([[0, 0, 0, 1]]).bool()), (None, torch.tensor([[0, 1, 0]]).bool(), torch.tensor([[0, 1, 0, 0]]).boo... |
class TestDataNoising(unittest.TestCase):
def _get_test_data_with_bpe_cont_marker(self, append_eos=True):
"\n Args:\n append_eos: if True, each input sentence in the source tokens tensor\n will have an EOS appended to the end.\n\n Returns:\n vocabs: BPE ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.