text stringlengths 1 93.6k |
|---|
if not os.path.exists(tb_dir):
|
os.makedirs(tb_dir)
|
writer = tensorboard.SummaryWriter(tb_dir)
|
# Initialize model.
|
score_model = mutils.create_model(config)
|
ema = ExponentialMovingAverage(score_model.parameters(), decay=config.model.ema_rate)
|
optimizer = losses.get_optimizer(config, score_model.parameters())
|
state = dict(optimizer=optimizer, model=score_model, ema=ema, step=0)
|
# Create checkpoints directly
|
checkpoint_dir = os.path.join(workdir, "checkpoints")
|
# Intermediate checkpoints to resume training
|
checkpoint_meta_dir = os.path.join(workdir, "checkpoints-meta", "checkpoint.pth")
|
if not os.path.exists(checkpoint_dir):
|
os.makedirs(checkpoint_dir)
|
if not os.path.exists(os.path.dirname(checkpoint_meta_dir)):
|
os.makedirs(os.path.dirname(checkpoint_meta_dir))
|
# Resume training when intermediate checkpoints are detected
|
state = restore_checkpoint(checkpoint_meta_dir, state, config.device)
|
initial_step = int(state['step'])
|
# Build dataloader and iterators
|
train_ds, eval_ds, test_ds, n_node_pmf = datasets.get_dataset(config)
|
train_loader = DataLoader(train_ds, batch_size=config.training.batch_size, shuffle=True)
|
eval_loader = DataLoader(eval_ds, batch_size=config.training.batch_size, shuffle=False)
|
test_loader = DataLoader(test_ds, batch_size=config.training.batch_size, shuffle=False)
|
n_node_pmf = torch.from_numpy(n_node_pmf).to(config.device)
|
train_iter = iter(train_loader)
|
# create data normalizer and its inverse
|
scaler = datasets.get_data_scaler(config)
|
inverse_scaler = datasets.get_data_inverse_scaler(config)
|
# Setup SDEs
|
if config.training.sde.lower() == 'vpsde':
|
sde = sde_lib.VPSDE(beta_min=config.model.beta_min, beta_max=config.model.beta_max, N=config.model.num_scales)
|
sampling_eps = 1e-3
|
else:
|
raise NotImplementedError(f"SDE {config.training.sde} unknown.")
|
# Build one-step training and evaluation functions
|
optimize_fn = losses.optimization_manager(config)
|
continuous = config.training.continuous
|
reduce_mean = config.training.reduce_mean
|
likelihood_weighting = config.training.likelihood_weighting
|
train_step_fn = losses.get_step_fn(sde, train=True, optimize_fn=optimize_fn,
|
reduce_mean=reduce_mean, continuous=continuous,
|
likelihood_weighting=likelihood_weighting)
|
eval_step_fn = losses.get_step_fn(sde, train=False, optimize_fn=optimize_fn,
|
reduce_mean=reduce_mean, continuous=continuous,
|
likelihood_weighting=likelihood_weighting)
|
# Build sampling functions
|
if config.training.snapshot_sampling:
|
sampling_shape = (config.training.eval_batch_size, config.data.num_channels,
|
config.data.max_node, config.data.max_node)
|
sampling_fn = sampling.get_sampling_fn(config, sde, sampling_shape, inverse_scaler, sampling_eps)
|
num_train_steps = config.training.n_iters
|
logging.info("Starting training loop at step %d." % (initial_step,))
|
for step in range(initial_step, num_train_steps + 1):
|
try:
|
graphs = next(train_iter)
|
except StopIteration:
|
train_iter = train_loader.__iter__()
|
graphs = next(train_iter)
|
adj, mask = dense_adj(graphs, config.data.max_node, scaler, config.data.dequantization)
|
batch = (adj, mask)
|
# Execute one training step
|
loss = train_step_fn(state, batch)
|
if step % config.training.log_freq == 0:
|
logging.info("step: %d, training_loss: %.5e" % (step, loss.item()))
|
writer.add_scalar("training_loss", loss, step)
|
# Save a temporary checkpoint to resume training after pre-emption periodically
|
if step != 0 and step % config.training.snapshot_freq_for_preemption == 0:
|
save_checkpoint(checkpoint_meta_dir, state)
|
# Report the loss on evaluation dataset periodically
|
if step % config.training.eval_freq == 0:
|
for eval_graphs in eval_loader:
|
eval_adj, eval_mask = dense_adj(eval_graphs, config.data.max_node, scaler)
|
eval_batch = (eval_adj, eval_mask)
|
eval_loss = eval_step_fn(state, eval_batch)
|
logging.info("step: %d, eval_loss: %.5e" % (step, eval_loss.item()))
|
writer.add_scalar("eval_loss", eval_loss.item(), step)
|
for test_graphs in test_loader:
|
test_adj, test_mask = dense_adj(test_graphs, config.data.max_node, scaler)
|
test_batch = (test_adj, test_mask)
|
test_loss = eval_step_fn(state, test_batch)
|
logging.info("step: %d, test_loss: %.5e" % (step, test_loss.item()))
|
writer.add_scalar("test_loss", test_loss.item(), step)
|
# Save a checkpoint periodically and generate samples
|
if step != 0 and step % config.training.snapshot_freq == 0 or step == num_train_steps:
|
# Save the checkpoint.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.