def test(args):
trainer = Trainer(args)
trainer.load_model()
for pair in trainer.test_data:
i, t, p = trainer.translate(pair)
logger.info('--' * 10)
logger.info('input: {}'.format(i))
logger.info('truth: {}'.format(t))
logger.info('predict: {}'.format(p))
def train(self, model, device):
from libs.trainer import Trainer
from utils.data_loader import CreateDataLoader
from utils.common import CommonUtils
train_loader, validate_loader = CreateDataLoader.build_for_train(self.exec_type, self.config)
trainer = Trainer(model, device, self.config, self.save_dir)
trainer.run(train_loader, validate_loader)
def main(args):
print(args)
trainer = Trainer(args)
evaluator = Evaluator(trainer)
for i_epoch in range(1, args.epoch + 1):
print('%dth epoch' % i_epoch)
log_dict = {}
log_dict['autoencoder'] = {}
log_dict['autoencoder']['tgt'] =\
trainer.train_one_epoch_autoencoder('tgt')
log_dict['autoencoder']['src'] =\
trainer.train_one_epoch_autoencoder('src')
log_dict['cross_domain'] = {}
log_dict['cross_domain']['tgt'] =\
trainer.train_one_epoch_cross_domain('tgt',
first_iter=i_epoch == 1)
log_dict['cross_domain']['src'] =\
trainer.train_one_epoch_cross_domain('src',
first_iter=i_epoch == 1)
disc_loss, gen_loss = trainer.train_one_epoch_adversarial()
log_dict['adversarial'] = {}
log_dict['adversarial']['disc'] = disc_loss
log_dict['adversarial']['gen'] = gen_loss
trainer.clip_current_model()
if i_epoch > 1:
log_dict['samples'] = evaluator.sample_translation()
pprint(log_dict)
def interactive(args):
trainer = Trainer(args)
trainer.load_model()
sent = input('input a sentence: ')
sent = sent.split() + ['</s>']
sent = utils.prepare_sequence(sent, trainer.s_w2i, False).view(1, -1)
src = sent
sent = ['fake', '</s>']
sent = utils.prepare_sequence(sent, trainer.s_w2i, False).view(1, -1)
tgt = sent
pair = (src, tgt)
i, t, p = trainer.translate(pair)
logger.info('--' * 10)
logger.info('input: {}'.format(i))
logger.info('predict: {}'.format(p))
def main(args):
print(args)
trainer = Trainer(args)
evaluator = Evaluator(trainer)
best_val_loss = 1e+10
for i_epoch in range(0, args.epoch + 1):
# train
log_dict = {} # per sample
log_dict['epoch'] = i_epoch
trainer.train_one_epoch(log_dict)
# trainer.translation_validate()
# evaluation and logging
evaluator.calc_test_loss(log_dict)
# evaluator.bleu(log_dict)
# evaluator.sample_translation()
if best_val_loss > log_dict['test_loss']:
best_val_loss = log_dict['test_loss']
trainer.dump_model(args.output_dir)
pprint(log_dict)
def train_parallel(rank, world_size, seed, config):
# This function is performed in parallel in several processes, one for each available GPU
os.environ['MASTER_ADDR'] = 'localhost'
os.environ['MASTER_PORT'] = '8882'
dist.init_process_group(backend='nccl', world_size=world_size, rank=rank)
torch.manual_seed(seed)
np.random.seed(seed)
torch.cuda.set_device(rank)
device = 'cuda:%d' % torch.cuda.current_device()
print("process %d, GPU: %s" % (rank, device))
# create model
config.model = PointDSC(
in_dim=config.in_dim,
num_layers=config.num_layers,
num_channels=config.num_channels,
num_iterations=config.num_iterations,
inlier_threshold=config.inlier_threshold,
sigma_d=config.sigma_d,
ratio=config.ratio,
k=config.k,
)
# create optimizer
if config.optimizer == 'SGD':
config.optimizer = optim.SGD(
config.model.parameters(),
lr=config.lr,
momentum=config.momentum,
weight_decay=config.weight_decay,
)
elif config.optimizer == 'ADAM':
config.optimizer = optim.Adam(
config.model.parameters(),
lr=config.lr,
betas=(0.9, 0.999),
# momentum=config.momentum,
weight_decay=config.weight_decay,
)
config.scheduler = optim.lr_scheduler.ExponentialLR(
config.optimizer,
gamma=config.scheduler_gamma,
)
# create dataset and dataloader
DL_config = edict({
'voxel_size': 0.3,
'positive_pair_search_voxel_size_multiplier': 4,
'use_random_rotation': False,
'use_random_scale': False
})
config.train_loader = make_data_loader(config.dataset,
DL_config,
'train',
config.batch_size,
rank,
world_size,
seed,
config.num_workers,
shuffle=True)
config.val_loader = make_data_loader(config.dataset,
DL_config,
'val',
config.batch_size,
rank,
world_size,
seed,
config.num_workers,
shuffle=False)
config.train_feature_extractor = LidarFeatureExtractor(
split='train',
in_dim=config.in_dim,
inlier_threshold=config.inlier_threshold,
num_node=config.num_node,
use_mutual=config.use_mutual,
augment_axis=config.augment_axis,
augment_rotation=config.augment_rotation,
augment_translation=config.augment_translation,
fcgf_weights_file=config.fcgf_weights_file)
config.val_feature_extractor = LidarFeatureExtractor(
split='val',
in_dim=config.in_dim,
inlier_threshold=config.inlier_threshold,
num_node=config.num_node,
use_mutual=config.use_mutual,
augment_axis=0,
augment_rotation=0.0,
augment_translation=0.0,
fcgf_weights_file=config.fcgf_weights_file)
# create evaluation
config.evaluate_metric = {
"ClassificationLoss":
ClassificationLoss(balanced=config.balanced),
"SpectralMatchingLoss":
SpectralMatchingLoss(balanced=config.balanced),
"TransformationLoss":
TransformationLoss(re_thre=config.re_thre, te_thre=config.te_thre),
}
config.metric_weight = {
"ClassificationLoss": config.weight_classification,
"SpectralMatchingLoss": config.weight_spectralmatching,
"TransformationLoss": config.weight_transformation,
}
trainer = Trainer(config, rank)
trainer.train()
num_node=config.num_node,
use_mutual=config.use_mutual,
downsample=config.downsample,
augment_axis=config.augment_axis,
augment_rotation=config.augment_rotation,
augment_translation=config.augment_translation,
)
config.train_loader = get_dataloader(dataset=train_set,
batch_size=config.batch_size,
num_workers=config.num_workers,
)
config.val_loader = get_dataloader(dataset=val_set,
batch_size=config.batch_size,
num_workers=config.num_workers,
)
# create evaluation
config.evaluate_metric = {
"ClassificationLoss": ClassificationLoss(balanced=config.balanced),
"SpectralMatchingLoss": SpectralMatchingLoss(balanced=config.balanced),
"TransformationLoss": TransformationLoss(re_thre=config.re_thre, te_thre=config.te_thre),
}
config.metric_weight = {
"ClassificationLoss": config.weight_classification,
"SpectralMatchingLoss": config.weight_spectralmatching,
"TransformationLoss": config.weight_transformation,
}
trainer = Trainer(config)
trainer.train()
net = MatrixLSTMResNet(
(params.input_height, params.input_width),
train_loader.dataset.num_classes, params.embedding_size,
params.hidden_size, params.region_shape, params.region_stride,
params.add_coords_feature, params.add_time_feature_mode,
params.normalize_relative, params.lstm_type,
params.keep_most_recent, params.frame_intervals,
params.frame_intervals_mode, params.resnet_type,
params.resnet_pretrain, params.resnet_freeze, params.eventdrop,
params.framedrop, params.fcdrop, params.frame_actfn,
params.resnet_meanstd_norm, params.resnet_add_last_fc,
params.lstm_num_layers, params.resnet_replace_first,
params.resnet_replace_first_bn, params.add_se_layer)
trainer = Trainer(net,
torch.optim.Adam,
train_loader,
val_loader,
test_loader,
params,
lr_scheduler=lr_scheduler)
acc = trainer.train_network()
acc_results.append(acc)
print("\n-------------------------")
print("Multiple seed evaluation:")
print("Results:", acc_results)
print("Aggregate result: {} +/- {}".format(np.mean(acc_results),
np.std(acc_results)))
def main():
warnings.filterwarnings('ignore', category=UserWarning)
parser = argparse.ArgumentParser()
parser.add_argument('--model', default='latent_ode')
parser.add_argument('--batch_size', default=256, type=int)
parser.add_argument('--n_epoch', default=100, type=int)
parser.add_argument('--version', default=1, type=int)
parser.add_argument('--train_dataset_size', default=1000, type=int)
parser.add_argument('--val_dataset_size', type=int)
parser.add_argument('--time_size', default=30, type=int)
parser.add_argument('--learning_rate', default=0.001, type=float)
parser.add_argument('--device', default='cpu', type=str)
parser.add_argument('--log_dir', default='./logs', type=str)
parser.add_argument('--save', dest='save', action='store_true')
parser.set_defaults(save=False)
parser.add_argument('--const_samples',
dest='const_samples',
action='store_true')
parser.set_defaults(const_samples=False)
args = parser.parse_args()
device = torch.device(args.device)
model = LatentODE(x_size=1,
z_size=64,
hid_size=128,
noise_sigma=0.01,
device=device,
reverse=False,
method='dopri5')
train_functions = FunctionsDataset(args.train_dataset_size,
np.linspace(0, 5, 100),
args.time_size,
t_predict_points=np.linspace(
5, 10, 100)[1:],
const_samples=args.const_samples)
train_dataloader = FunctionsDataLoader(train_functions,
batch_size=args.batch_size)
val_dataset_size = args.val_dataset_size if args.val_dataset_size is not None else args.train_dataset_size
val_functions = FunctionsDataset(val_dataset_size,
np.linspace(0, 5, 100),
args.time_size,
t_predict_points=np.linspace(5, 10,
100)[1:],
const_samples=args.const_samples)
val_dataloader = FunctionsDataLoader(val_functions,
batch_size=args.batch_size,
shuffle=False)
trainer = Trainer(model,
args.model,
train_dataloader,
val_dataloader,
device=device,
version=args.version,
log_dir=args.log_dir,
learning_rate=args.learning_rate,
custom_time=np.linspace(5, 30, 600))
trainer.train(args.n_epoch, args.save)
def train(args):
trainer = Trainer(args)
trainer.train()
import argparse
from distutils.util import strtobool
from libs.trainer import Trainer
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--data-dir', type=str, default='../DATA/giga-fren')
parser.add_argument('--src-lang', type=str, default='fr')
parser.add_argument('--tgt-lang', type=str, default='en')
parser.add_argument('--batch-size', type=int, default=8)
parser.add_argument('--src-vocab-size', type=int, default=30000)
parser.add_argument('--tgt-vocab-size', type=int, default=30000)
parser.add_argument('--src-embedding-size', type=int, default=256)
parser.add_argument('--encoder-dropout-p', type=float, default=0.1)
parser.add_argument('--encoder-hidden-n', type=int, default=256)
parser.add_argument('--encoder-num-layers', type=int, default=1)
parser.add_argument('--tgt-embedding-size', type=int, default=256)
parser.add_argument('--decoder-dropout-p', type=float, default=0.1)
parser.add_argument('--decoder-hidden-n', type=int, default=256)
parser.add_argument('--decoder-num-layers', type=int, default=1)
parser.add_argument('--lr', type=float, default=0.001)
parser.add_argument('--use-cuda', type=strtobool, default='1')
parser.add_argument('--encoder-bidirectional', type=strtobool, default='0')
parser.add_argument('--decoder-bidirectional', type=strtobool, default='0')
args = parser.parse_args()
print(args)
trainer = Trainer(args)
for _ in range(50):
trainer.train_one_epoch()