def _update_baseline(self, model, epoch):
# Load or copy baseline model based on self.from_checkpoint condition
if self.from_checkpoint and self.alpha == 0:
print('Baseline model loaded')
self.model = self.load_model(self.path_to_checkpoint,
embed_dim=self.embed_dim,
n_customer=self.n_customer)
else:
print('Baseline model copied')
self.model = self.copy_model(model)
# For checkpoint
torch.save(self.model.state_dict(),
'%s%s_epoch%s.pt' % (self.weight_dir, self.task, epoch))
self.model = self.model.to(self.device)
# We generate a new dataset for baseline model on each baseline update to prevent possible overfitting
self.dataset = Generator(n_samples=self.n_rollout_samples,
n_customer=self.n_customer)
print(
f'Evaluating baseline model on baseline dataset (epoch = {epoch})')
self.bl_vals = self.rollout(self.model, self.dataset).cpu().numpy()
self.mean = self.bl_vals.mean()
self.cur_epoch = epoch
def main():
batch_size = 8
Epochs = 50
learning_rate = 0.0005
weights_path = 'weights/'
directory = 'logs/'
img_size = 320
opt = tf.compat.v1.train.AdamOptimizer(learning_rate=learning_rate)
opt = tf.train.experimental.enable_mixed_precision_graph_rewrite(opt)
# Prepare model.
model = unet(input_shape=(img_size, img_size, 3), num_cls=32)
model.summary()
model.compile(optimizer=opt,
loss=binary_crossentropy,
metrics=['accuracy'])
checkpoint = ModelCheckpoint(
weights_path +
'ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}-val_accuracy{val_accuracy:.3f}1.h5',
monitor='val_accuracy',
save_weights_only=True,
save_best_only=True,
mode='max',
period=1)
tensorboard = TensorBoard(log_dir=directory, batch_size=batch_size)
callbacks = [checkpoint, tensorboard]
# Training.
model.fit_generator(generator=Generator(batch_size=batch_size,
image_shape=(img_size, img_size),
shuffle=True,
folder="train"),
steps_per_epoch=int(473 / batch_size),
validation_data=Generator(batch_size=batch_size,
image_shape=(img_size,
img_size),
shuffle=False,
folder="val"),
validation_steps=int(162 / batch_size),
epochs=Epochs,
shuffle=True,
verbose=1,
callbacks=callbacks)
def init(self):
with open("conf/train.yml", 'r') as ymlfile:
cfg = yaml.load(ymlfile)
self.Config = Configuration(**cfg)
if self.Config.device is None:
self.Config.device = "cuda:0" if torch.cuda.is_available(
) else "cpu"
self.device = torch.device(self.Config.device)
#if self.device == torch.device("cuda:0"):
# Config.pin_memory = True
torch.set_num_threads(self.Config.num_threads)
self.stepper = Stepper(self.Config, self.device)
self.t_gen = Generator(self.Config, self.stepper.vocab, self.device)
self.v_gen = Generator(self.Config, self.stepper.vocab, self.device)
self.train_iter = self.t_gen('train')
self.val_iter = self.v_gen('val')
def train_model(cfg, env, log_path=None):
date = datetime.now().strftime('%m%d_%H_%M')
if cfg.islogger:
param_path = cfg.log_dir + '%s_%s_param.csv' % (
date, cfg.task) # cfg.log_dir = ./Csv/
print(f'generate {param_path}')
with open(param_path, 'w') as f:
f.write(''.join('%s,%s\n' % item for item in vars(cfg).items()))
act_model = PtrNet1(cfg)
if cfg.optim == 'Adam':
act_optim = optim.Adam(act_model.parameters(), lr=cfg.lr)
if cfg.is_lr_decay:
act_lr_scheduler = optim.lr_scheduler.StepLR(
act_optim, step_size=cfg.lr_decay_step, gamma=cfg.lr_decay)
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
act_model = act_model.to(device)
if cfg.mode == 'train':
cri_model = PtrNet2(cfg)
if cfg.optim == 'Adam':
cri_optim = optim.Adam(cri_model.parameters(), lr=cfg.lr)
if cfg.is_lr_decay:
cri_lr_scheduler = optim.lr_scheduler.StepLR(
cri_optim, step_size=cfg.lr_decay_step, gamma=cfg.lr_decay)
cri_model = cri_model.to(device)
ave_cri_loss = 0.
mse_loss = nn.MSELoss()
dataset = Generator(cfg, env)
dataloader = DataLoader(dataset, batch_size=cfg.batch, shuffle=True)
ave_act_loss, ave_L = 0., 0.
min_L, cnt = 1e7, 0
t1 = time()
# for i, inputs in tqdm(enumerate(dataloader)):
for i, inputs in enumerate(dataloader):
inputs = inputs.to(device)
pred_tour, ll = act_model(inputs, device)
real_l = env.stack_l_fast(inputs, pred_tour)
if cfg.mode == 'train':
pred_l = cri_model(inputs, device)
cri_loss = mse_loss(pred_l, real_l.detach())
cri_optim.zero_grad()
cri_loss.backward()
nn.utils.clip_grad_norm_(cri_model.parameters(),
max_norm=1.,
norm_type=2)
cri_optim.step()
if cfg.is_lr_decay:
cri_lr_scheduler.step()
elif cfg.mode == 'train_emv':
if i == 0:
L = real_l.detach().mean()
else:
L = (L * 0.9) + (0.1 * real_l.detach().mean())
pred_l = L
adv = real_l.detach() - pred_l.detach()
act_loss = (adv * ll).mean()
act_optim.zero_grad()
act_loss.backward()
nn.utils.clip_grad_norm_(act_model.parameters(),
max_norm=1.,
norm_type=2)
act_optim.step()
if cfg.is_lr_decay:
act_lr_scheduler.step()
ave_act_loss += act_loss.item()
if cfg.mode == 'train':
ave_cri_loss += cri_loss.item()
ave_L += real_l.mean().item()
if i % cfg.log_step == 0:
t2 = time()
if cfg.mode == 'train':
print(
'step:%d/%d, actic loss:%1.3f, critic loss:%1.3f, L:%1.3f, %dmin%dsec'
% (i, cfg.steps, ave_act_loss / (i + 1), ave_cri_loss /
(i + 1), ave_L / (i + 1), (t2 - t1) // 60,
(t2 - t1) % 60))
if cfg.islogger:
if log_path is None:
log_path = cfg.log_dir + '%s_%s_train.csv' % (
date, cfg.task) # cfg.log_dir = ./Csv/
with open(log_path, 'w') as f:
f.write(
'step,actic loss,critic loss,average distance,time\n'
)
else:
with open(log_path, 'a') as f:
f.write('%d,%1.4f,%1.4f,%1.4f,%dmin%dsec\n' %
(i, ave_act_loss / (i + 1), ave_cri_loss /
(i + 1), ave_L / (i + 1), (t2 - t1) // 60,
(t2 - t1) % 60))
elif cfg.mode == 'train_emv':
print('step:%d/%d, actic loss:%1.3f, L:%1.3f, %dmin%dsec' %
(i, cfg.steps, ave_act_loss / (i + 1), ave_L / (i + 1),
(t2 - t1) // 60, (t2 - t1) % 60))
if cfg.islogger:
if log_path is None:
log_path = cfg.log_dir + '%s_%s_train_emv.csv' % (
date, cfg.task) # cfg.log_dir = ./Csv/
with open(log_path, 'w') as f:
f.write('step,actic loss,average distance,time\n')
else:
with open(log_path, 'a') as f:
f.write('%d,%1.4f,%1.4f,%dmin%dsec\n' %
(i, ave_act_loss / (i + 1), ave_L /
(i + 1), (t2 - t1) // 60, (t2 - t1) % 60))
if (ave_L / (i + 1) < min_L):
min_L = ave_L / (i + 1)
else:
cnt += 1
print(f'cnt: {cnt}/20')
if (cnt >= 20):
print('early stop, average cost cant decrease anymore')
if log_path is not None:
with open(log_path, 'a') as f:
f.write('\nearly stop')
break
t1 = time()
if cfg.issaver:
torch.save(act_model.state_dict(),
cfg.model_dir + '%s_%s_step%d_act.pt' %
(cfg.task, date, i)) # 'cfg.model_dir = ./Pt/'
print('save model...')
def train(cfg, log_path=None):
torch.backends.cudnn.benchmark = True
def rein_loss(model, inputs, bs, t, device):
inputs = list(map(lambda x: x.to(device), inputs))
L, ll = model(inputs, decode_type='sampling')
b = bs[t] if bs is not None else baseline.eval(inputs, L)
return ((L - b.to(device)) * ll).mean(), L.mean()
model = AttentionModel(cfg.embed_dim, cfg.n_encode_layers, cfg.n_heads,
cfg.tanh_clipping)
model.train()
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model.to(device)
baseline = RolloutBaseline(model, cfg.task, cfg.weight_dir,
cfg.n_rollout_samples, cfg.embed_dim,
cfg.n_customer, cfg.warmup_beta, cfg.wp_epochs,
device)
optimizer = optim.Adam(model.parameters(), lr=cfg.lr)
t1 = time()
for epoch in range(cfg.epochs):
ave_loss, ave_L = 0., 0.
dataset = Generator(cfg.batch * cfg.batch_steps, cfg.n_customer)
bs = baseline.eval_all(dataset)
bs = bs.view(
-1, cfg.batch
) if bs is not None else None # bs: (cfg.batch_steps, cfg.batch) or None
dataloader = DataLoader(dataset, batch_size=cfg.batch, shuffle=True)
for t, inputs in enumerate(dataloader):
loss, L_mean = rein_loss(model, inputs, bs, t, device)
optimizer.zero_grad()
loss.backward()
# print('grad: ', model.Decoder.Wk1.weight.grad[0][0])
# https://github.com/wouterkool/attention-learn-to-route/blob/master/train.py
nn.utils.clip_grad_norm_(model.parameters(),
max_norm=1.0,
norm_type=2)
optimizer.step()
ave_loss += loss.item()
ave_L += L_mean.item()
if t % (cfg.batch_verbose) == 0:
t2 = time()
print(
'Epoch %d (batch = %d): Loss: %1.3f L: %1.3f, %dmin%dsec' %
(epoch, t, ave_loss / (t + 1), ave_L / (t + 1),
(t2 - t1) // 60, (t2 - t1) % 60))
if cfg.islogger:
if log_path is None:
log_path = '%s%s_%s.csv' % (
cfg.log_dir, cfg.task, cfg.dump_date
) #cfg.log_dir = ./Csv/
with open(log_path, 'w') as f:
f.write('time,epoch,batch,loss,cost\n')
with open(log_path, 'a') as f:
f.write('%dmin%dsec,%d,%d,%1.3f,%1.3f\n' %
((t2 - t1) // 60,
(t2 - t1) % 60, epoch, t, ave_loss /
(t + 1), ave_L / (t + 1)))
t1 = time()
baseline.epoch_callback(model, epoch)
torch.save(model.state_dict(),
'%s%s_epoch%s.pt' % (cfg.weight_dir, cfg.task, epoch))
CFG['device'])
CONFIG = state['Config']
CONFIG.device = CFG['device']
CONFIG.resume = True
CONFIG.from_save_description = CFG['from_save_description']
CONFIG.from_epoch = CFG['from_epoch']
CONFIG.vocab_path = get_vocab_path(CONFIG.dataset)
CONFIG.eval_beam = True
CONFIG.meteor = CFG['meteor']
CONFIG.dump = CFG['dump']
CONFIG.batch_size = CFG['batch_size']
printConfig(CONFIG)
STEPPER = Stepper(CONFIG, DEVICE)
STEPPER.eval()
V_GEN = Generator(CONFIG, STEPPER.vocab, STEPPER.device)
def validate():
validation_time = -time.time()
sum_loss = 0
i = 0
total_val_count, beam_count, beam_meteor = 0, [], 0
rouge_beam_val_dicts = []
val_iter = V_GEN(CFG['partition'])
for batch in val_iter:
n = batch.__len__()
total_val_count += n
_, beam_dict, loss, _ = STEPPER.forward_mle(batch)
sum_loss += loss.item()
def generate_dataset(config):
Generator.generate_dataset(config)