def delay_20(agi):
util.metric(agi, 'delay-20')
agi.appexec('wait', 5)
util.say(agi, 'please-hold')
agi.appexec('wait', 1)
util.say(agi, 'for-the-next-available-outgoing-line')
agi.appexec('wait', 3)
agi.appexec('MusicOnHold', ',6')
agi.appexec('wait', 1)
def yt_scan(bot, url):
if bot.config.get("module: open_graph", "youtube") == "off":
return None
url = re.sub("http(s)?://", "", url)
regex = "^(?:www\\.)?(?:(?:youtube\\.com/(?:watch)?(?:[?&][a-z]+=[a-z_]+)?(?:[?&]v=))|(?:youtu\\.be\\/))([a-zA-Z0-9-_]+)"
apiurl = "http://gdata.youtube.com/feeds/api/videos/%s?v=2&alt=jsonc" % re.findall(regex, url)[0]
bot._debug("API URL: %s" % apiurl)
result = urllib2.urlopen(apiurl)
jsondata = json.load(result)
title = jsondata['data']['title']
author = jsondata['data']['uploader']
length = util.time_metric(secs=jsondata['data']['duration'])
likes = util.metric(int(jsondata['data']['likeCount']))
dislikes = util.metric(int(jsondata['data']['ratingCount']) - int(jsondata['data']['likeCount']))
views = util.metric(int(jsondata['data']['viewCount']))
fmt = "\x02You\x034Tube\x0f: \x02%s\x0f by %s [%s] [\x033+%s\x0f \x035-%s\x0f] [%sv]" % (title, author, length, likes, dislikes, views)
util.answer(bot, fmt.encode('utf-8'))
def train(train_loader):
epoch_loss = []
train_pred = []
train_label = []
for i, (x, y) in enumerate(train_loader, 0):
x = x.cuda()
y = y.cuda()
optimizer.zero_grad()
normalization_label = y[:, :, :, 0].cpu().detach().numpy()
# STGCN
# out = net(A_wave, x)
out = net(x)
pred = util.re_normalization(out, mean[0], std[0])
label = util.re_normalization(normalization_label, mean[0], std[0])
loss = criterion(out, y[:, :, :, 0])
loss.backward()
optimizer.step()
epoch_loss.append(loss.detach().cpu().numpy())
train_pred.append(pred.cpu().detach().numpy())
train_label.append(label)
if (i + 1) % 20 == 0:
pred = np.concatenate(train_pred, axis=0)
label = np.concatenate(train_label, axis=0)
train_mae, train_rmse, train_mape, b = util.metric(pred, label)
print("[epoch %d][%d/%d] loss: %.4f mae: %.4f rmse: %.4f " %
(epoch, i + 1, len(train_loader), loss.item(), train_mae,
train_rmse))
train_mae, train_rmse, train_mape, b = util.metric(train_pred, train_label)
return train_rmse, sum(epoch_loss)
def eval(model, data_eval, voc_size, epoch):
eval_len = len(data_eval)
# evaluate
print('')
model.eval()
y_pred_prob = np.zeros((eval_len, voc_size[-1]))
y_gt = y_pred_prob.copy()
y_pred = y_pred_prob.copy()
for step, input in enumerate(data_eval):
pre_outputs, pre_labels, last_outputs, last_labels = model(input)
last_outputs = F.softmax(last_outputs, dim=-1)
last_v, last_arg = torch.max(last_outputs, dim=-1)
last_v = last_v.detach().cpu().numpy()
last_arg = last_arg.detach().cpu().numpy()
def filter_other_token(x):
if x[1] >= voc_size[-1]:
return False
return True
try:
last_v, last_arg = zip(
*filter(filter_other_token, zip(last_v, last_arg)))
except Exception:
last_v, last_arg = [], []
last_v, last_arg = list(last_v), list(last_arg)
target = last_labels.detach().cpu().numpy()[:-1] # remove end token
pred_prob = np.zeros(voc_size[-1])
pred_prob[last_arg] = last_v
pred = pred_prob.copy()
pred[last_arg] = 1
y_pred[step, :] = pred
y_pred_prob[step, :] = pred_prob
y_gt[step, target] = 1
llprint('\rEval--Epoch: %d, Step: %d/%d' %
(epoch, step, len(data_eval)))
js, auc, p_1, p_3, p_5, f1, auprc = metric(y_gt, y_pred, y_pred_prob)
llprint(
'\tJS: %.4f, AUC: %.4f, P1: %.4f, P3: %.4f, P5: %.4f, F1: %.4f, AUPRC: %.4F\n'
% (js, auc, p_1, p_3, p_5, f1, auprc))
def vmauthenticate(agi):
"""Authenticate a voice mailbox and continue, or busy."""
util.metric(agi, 'friction-vmauthenticate')
# Note vmauthenticate lets user jump to 'a' extension if existing,
# so don't call this in a context that defines that!
try:
util.say(agi, 'authenticate-with-your-voice-mail-box-to-continue')
res = agi.appexec('VMAuthenticate')
except Exception as exc:
# we expect AGIAppError('Error executing application, or hangup',)
util.metric(agi, 'friction-vmauthenticate-deny')
agi.appexec('busy')
# above command should not exit
else:
util.metric(agi, 'friction-vmauthenticate-allow')
def vmauthenticate(agi):
"""Authenticate a voice mailbox and continue, or busy."""
util.metric(agi, 'friction-vmauthenticate')
# Note vmauthenticate lets user jump to 'a' extension if existing,
# so don't call this in a context that defines that!
try:
util.say(agi, 'authenticate-with-your-voice-mail-box-to-continue')
res = agi.appexec('VMAuthenticate')
except Exception as exc:
# we expect AGIAppError('Error executing application, or hangup',)
util.metric(agi, 'friction-vmauthenticate-deny')
agi.appexec('busy')
# above command should not exit
else:
util.metric(agi, 'friction-vmauthenticate-allow')
def delay_10(agi):
util.metric(agi, 'delay-10')
agi.appexec('wait', 5)
agi.appexec('MusicOnHold', ',5')
def context_restricted_dialtone(agi):
util.metric(agi, 'friction-context-restricted-dialtone')
agi.set_context('restricted-outgoing-dialtone-wrapper')
agi.set_extension('s')
agi.set_priority(1)
def main():
device = torch.device(args.device)
_, _, adj_mx = util.load_adj(args.adjdata, args.adjtype)
supports = [torch.tensor(i).to(device) for i in adj_mx]
if args.randomadj:
adjinit = None
else:
adjinit = supports[0]
if args.aptonly:
supports = None
model = gwnet(device,
args.num_nodes,
args.dropout,
supports=supports,
gcn_bool=args.gcn_bool,
addaptadj=args.addaptadj,
aptinit=adjinit)
model.to(device)
model.load_state_dict(torch.load(args.checkpoint))
model.eval()
print('model load successfully')
dataloader = util.load_dataset(args.data, args.batch_size, args.batch_size,
args.batch_size)
scaler = dataloader['scaler']
outputs = []
realy = torch.Tensor(dataloader['y_test']).to(device)
realy = realy.transpose(1, 3)[:, 0, :, :]
for iter, (x, y) in enumerate(dataloader['test_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
testx = testx.transpose(1, 3)
with torch.no_grad():
preds = model(testx).transpose(1, 3)
outputs.append(preds.squeeze())
yhat = torch.cat(outputs, dim=0)
yhat = yhat[:realy.size(0), ...]
amae = []
amape = []
armse = []
for i in range(12):
pred = scaler.inverse_transform(yhat[:, :, i])
real = scaler.inverse_transform(realy[:, :, i])
metrics = util.metric(pred, real)
log = 'Evaluate best model on test data for horizon {:d}, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(i + 1, metrics[0], metrics[1], metrics[2]))
amae.append(metrics[0])
amape.append(metrics[1])
armse.append(metrics[2])
log = 'On average over 12 horizons, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(np.mean(amae), np.mean(amape), np.mean(armse)))
if args.plotheatmap == "True":
adp = F.softmax(F.relu(torch.mm(model.nodevec1, model.nodevec2)),
dim=1)
device = torch.device('cpu')
adp.to(device)
adp = adp.cpu().detach().numpy()
adp = adp * (1 / np.max(adp))
df = pd.DataFrame(adp)
sns.heatmap(df, cmap="RdYlBu")
plt.savefig("./emb" + '.pdf')
y12 = np.array(scaler.inverse_transform(realy[:, 99, 11]))
yhat12 = np.array(scaler.inverse_transform(yhat[:, 99, 11]))
y3 = np.array(scaler.inverse_transform(realy[:, 99, 2]))
yhat3 = np.array(scaler.inverse_transform(yhat[:, 99, 2]))
df2 = pd.DataFrame({
'real12': y12,
'pred12': yhat12,
'real3': y3,
'pred3': yhat3
})
df2.to_csv('./wave.csv', index=False)
def main():
#set seed
#torch.manual_seed(args.seed)
#np.random.seed(args.seed)
#load data
device = torch.device(args.device)
sensor_ids, sensor_id_to_ind, adj_mx = util.load_adj(args.adjdata,args.adjtype)
dataloader = util.load_dataset(args.data, args.batch_size, args.batch_size, args.batch_size)
scaler = dataloader['scaler']
supports = [torch.tensor(i).to(device) for i in adj_mx]
print(args)
if args.randomadj:
adjinit = None
else:
adjinit = supports[0]
if args.aptonly:
supports = None
engine = trainer(scaler, args.in_dim, args.seq_length, args.num_nodes, args.nhid, args.dropout,
args.learning_rate, args.weight_decay, device, supports, args.gcn_bool, args.addaptadj,
adjinit)
print("start training...",flush=True)
his_loss =[]
val_time = []
train_time = []
for i in range(1,args.epochs+1):
#if i % 10 == 0:
#lr = max(0.000002,args.learning_rate * (0.1 ** (i // 10)))
#for g in engine.optimizer.param_groups:
#g['lr'] = lr
train_loss = []
train_mape = []
train_rmse = []
t1 = time.time()
dataloader['train_loader'].shuffle()
for iter, (x, y) in enumerate(dataloader['train_loader'].get_iterator()):
trainx = torch.Tensor(x).to(device)
trainx= trainx.transpose(1, 3)
trainy = torch.Tensor(y).to(device)
trainy = trainy.transpose(1, 3)
metrics = engine.train(trainx, trainy[:,0,:,:])
train_loss.append(metrics[0])
train_mape.append(metrics[1])
train_rmse.append(metrics[2])
if iter % args.print_every == 0 :
log = 'Iter: {:03d}, Train Loss: {:.4f}, Train MAPE: {:.4f}, Train RMSE: {:.4f}'
print(log.format(iter, train_loss[-1], train_mape[-1], train_rmse[-1]),flush=True)
t2 = time.time()
train_time.append(t2-t1)
#validation
valid_loss = []
valid_mape = []
valid_rmse = []
s1 = time.time()
for iter, (x, y) in enumerate(dataloader['val_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
testx = testx.transpose(1, 3)
testy = torch.Tensor(y).to(device)
testy = testy.transpose(1, 3)
metrics = engine.eval(testx, testy[:,0,:,:])
valid_loss.append(metrics[0])
valid_mape.append(metrics[1])
valid_rmse.append(metrics[2])
s2 = time.time()
log = 'Epoch: {:03d}, Inference Time: {:.4f} secs'
print(log.format(i,(s2-s1)))
val_time.append(s2-s1)
mtrain_loss = np.mean(train_loss)
mtrain_mape = np.mean(train_mape)
mtrain_rmse = np.mean(train_rmse)
mvalid_loss = np.mean(valid_loss)
mvalid_mape = np.mean(valid_mape)
mvalid_rmse = np.mean(valid_rmse)
his_loss.append(mvalid_loss)
log = 'Epoch: {:03d}, Train Loss: {:.4f}, Train MAPE: {:.4f}, Train RMSE: {:.4f}, Valid Loss: {:.4f}, Valid MAPE: {:.4f}, Valid RMSE: {:.4f}, Training Time: {:.4f}/epoch'
print(log.format(i, mtrain_loss, mtrain_mape, mtrain_rmse, mvalid_loss, mvalid_mape, mvalid_rmse, (t2 - t1)),flush=True)
torch.save(engine.model.state_dict(), args.save+"_epoch_"+str(i)+"_"+str(round(mvalid_loss,2))+".pth")
print("Average Training Time: {:.4f} secs/epoch".format(np.mean(train_time)))
print("Average Inference Time: {:.4f} secs".format(np.mean(val_time)))
#testing
bestid = np.argmin(his_loss)
engine.model.load_state_dict(torch.load(args.save+"_epoch_"+str(bestid+1)+"_"+str(round(his_loss[bestid],2))+".pth"))
outputs = []
realy = torch.Tensor(dataloader['y_test']).to(device)
realy = realy.transpose(1,3)[:,0,:,:]
for iter, (x, y) in enumerate(dataloader['test_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
testx = testx.transpose(1,3)
with torch.no_grad():
preds = engine.model(testx).transpose(1,3)
outputs.append(preds.squeeze())
yhat = torch.cat(outputs,dim=0)
yhat = yhat[:realy.size(0),...]
print("Training finished")
print("The valid loss on best model is", str(round(his_loss[bestid],4)))
amae = []
amape = []
armse = []
for i in range(12):
pred = scaler.inverse_transform(yhat[:,:,i])
real = realy[:,:,i]
metrics = util.metric(pred,real)
log = 'Evaluate best model on test data for horizon {:d}, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(i+1, metrics[0], metrics[1], metrics[2]))
amae.append(metrics[0])
amape.append(metrics[1])
armse.append(metrics[2])
log = 'On average over 12 horizons, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(np.mean(amae),np.mean(amape),np.mean(armse)))
torch.save(engine.model.state_dict(), args.save+"_exp"+str(args.expid)+"_best_"+str(round(his_loss[bestid],2))+".pth")
def main():
device = torch.device(args.device)
_, _, adj_mx = util.load_adj(args.adjdata, args.adjtype)
supports = [torch.tensor(i).to(device) for i in adj_mx]
if args.randomadj:
adjinit = None
else:
adjinit = supports[0]
if args.aptonly:
supports = None
eR_seq_size = 24 # 24
dataloader = util.load_dataset(args.data,
args.batch_size,
args.batch_size,
args.batch_size,
eRec=args.eRec,
eR_seq_size=eR_seq_size,
suffix=args.suffix_train)
scaler = dataloader['scaler']
dataloader = util.load_dataset(args.data,
args.batch_size,
args.batch_size,
args.batch_size,
eRec=args.eRec,
eR_seq_size=eR_seq_size,
suffix=args.suffix,
scaler=scaler)
blocks = int(dataloader[f'x_test{args.suffix}'].shape[1] /
3) # Every block reduce the input sequence size by 3.
print(f'blocks = {blocks}')
if args.eRec:
error_size = 6
model = eRGwnet(device,
args.num_nodes,
args.dropout,
supports=supports,
gcn_bool=args.gcn_bool,
addaptadj=args.addaptadj,
adjinit=adjinit,
in_dim=args.in_dim,
out_dim=args.seq_length,
residual_channels=args.nhid,
dilation_channels=args.nhid,
skip_channels=args.nhid * 8,
end_channels=args.nhid * 16,
blocks=blocks,
error_size=error_size)
else:
model = gwnet(device,
args.num_nodes,
args.dropout,
supports=supports,
gcn_bool=args.gcn_bool,
addaptadj=args.addaptadj,
adjinit=adjinit,
in_dim=args.in_dim,
out_dim=args.seq_length,
residual_channels=args.nhid,
dilation_channels=args.nhid,
skip_channels=args.nhid * 8,
end_channels=args.nhid * 16,
blocks=blocks)
model.to(device)
model.load_state_dict(
torch.load(args.checkpoint, map_location=torch.device(device)))
model.eval()
print('model load successfully')
outputs = []
realy = torch.Tensor(dataloader[f'y_test{args.suffix}']).to(device)
if args.eRec:
realy = realy.transpose(0, 1)[-1, :, :, :, :]
realy = realy.transpose(1, 3)[:, 0, :, :]
for iter, (x, y) in enumerate(dataloader['test_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
testy = torch.Tensor(y).to(device)
if args.eRec:
testx = testx.transpose(0, 1)
testy = testy.transpose(0, 1)
testx = testx.transpose(-3, -1)
testy = testy.transpose(-3, -1)
# print(f'testx.shape = {testx.shape}')
with torch.no_grad():
if args.eRec:
preds = model(testx, testy[:, :, 0:1, :, :],
scaler).transpose(1, 3)
else:
preds = model(testx).transpose(1, 3)
outputs.append(preds.squeeze())
yhat = torch.cat(outputs, dim=0)
print(f'yhat before shape = {yhat.shape}')
yhat = yhat[:realy.size(0), ...]
print(f'yhat shape = {yhat.shape}')
amae = []
amape = []
armse = []
for i in range(args.seq_length):
pred = scaler.inverse_transform(yhat[:, :, i])
real = realy[:, :, i]
metrics = util.metric(pred, real)
log = 'Evaluate best model on test data for horizon {:d}, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(i + 1, metrics[0], metrics[1], metrics[2]))
amae.append(metrics[0])
amape.append(metrics[1])
armse.append(metrics[2])
log = 'On average over 12 horizons, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(np.mean(amae), np.mean(amape), np.mean(armse)))
mse = nn.MSELoss(reduction='none')
mae = nn.L1Loss(reduction='none')
pred = scaler.inverse_transform(yhat)
loss_mse = mse(pred, realy).transpose(1, 2)
loss_mae = mae(pred, realy).transpose(1, 2)
print(f'loss_mae shape = {loss_mae.shape}')
if not args.eRec:
model_name = f'gwnet{args.suffix}'
else:
model_name = f'eRgwnet{args.suffix}'
print_results(model_name, loss_mse, loss_mae)
plot_results(model_name, loss_mae, detector=1)
if args.plotheatmap == "True":
adp = F.softmax(F.relu(torch.mm(model.nodevec1, model.nodevec2)),
dim=1)
device = torch.device('cpu')
adp.to(device)
adp = adp.cpu().detach().numpy()
adp = adp * (1 / np.max(adp))
df = pd.DataFrame(adp)
sns.heatmap(df, cmap="RdYlBu")
plt.savefig("./emb" + '.pdf')
y12 = realy[:, -1, -1].cpu().detach().numpy()
yhat12 = scaler.inverse_transform(yhat[:, -1, -1]).cpu().detach().numpy()
y3 = realy[:, -1, 2].cpu().detach().numpy()
yhat3 = scaler.inverse_transform(yhat[:, -1, 2]).cpu().detach().numpy()
df2 = pd.DataFrame({
'real12': y12,
'pred12': yhat12,
'real3': y3,
'pred3': yhat3
})
df2.to_csv('./wave.csv', index=False)
def main():
#set seed
#torch.manual_seed(args.seed)
#np.random.seed(args.seed)
#load data
frequencies = np.array([
8.176, 8.662, 9.177, 9.723, 10.301, 10.913, 11.562, 12.250, 12.978,
13.750, 14.568, 15.434, 16.352, 17.324, 18.354, 19.445, 20.601, 21.826,
23.124, 24.499, 25.956, 27.500, 29.135, 30.867, 32.703, 34.648, 36.708,
38.890, 41.203, 43.653, 46.249, 48.999, 51.913, 55.000, 58.270, 61.735,
65.406, 69.295, 73.416, 77.781, 82.406, 87.307, 92.499, 97.998, 103.82,
110.00, 116.54, 123.47, 130.81, 138.59, 146.83, 155.56, 164.81, 174.61,
184.99, 195.99, 207.65, 220.00, 233.08, 246.94, 261.63, 277.18, 293.66,
311.13, 329.63, 349.23, 369.99, 391.99, 415.31, 440.00, 466.16, 439.88,
523.25, 554.37, 587.33, 622.25, 659.26, 698.46, 739.99, 783.99, 830.61,
880.00, 932.32, 987.77, 1046.5, 1108.7, 1174.7, 1244.5, 1318.5, 1396.9,
1480.0, 1568.0, 1661.2, 1760.0, 1864.7, 1975.5, 2093.0, 2217.5, 2349.3,
2489.0, 2637.0, 2793.8, 2960.0, 3136.0, 3322.4, 3520.0, 3729.3, 3951.1,
4186.0, 4434.9, 4698.6, 4978.0, 5274.0, 5587.7, 5919.9, 6271.9, 6644.9,
7040.0, 7458.6, 7902.1, 8372.0, 8869.8, 9397.3, 9956.1, 10548.1,
11175.3, 11839.8, 12543.9
])
piano_adj = np.zeros((128, 128))
for row in range(128):
piano_adj[row] = frequencies - frequencies[row]
print(piano_adj[10:20, 10:20])
device = torch.device(args.device)
adj_mx = util.load_piano_adj(piano_adj, args.adjtype)
dataloader = util.load_dataset(args.data, args.batch_size, args.batch_size,
args.batch_size)
scaler = dataloader['scaler']
supports = [torch.tensor(i).to(device) for i in adj_mx]
print(type(adj_mx))
print(len(adj_mx))
for elem in adj_mx:
print(type(elem))
print(elem[10:20, 10:20])
print(elem.shape)
print(args)
time.sleep(2)
print("tsadf" + 24)
if args.randomadj:
adjinit = None
else:
adjinit = supports[0]
if args.aptonly:
supports = None
# print(adjinit)
# # print(supports[0])
# print("sfdssg" + 234)
engine = trainer(scaler, args.in_dim, args.seq_length, args.num_nodes,
args.nhid, args.dropout, args.learning_rate,
args.weight_decay, device, supports, args.gcn_bool,
args.addaptadj, adjinit)
print("start training...", flush=True)
his_loss = []
val_time = []
train_time = []
for i in range(1, args.epochs + 1):
#if i % 10 == 0:
#lr = max(0.000002,args.learning_rate * (0.1 ** (i // 10)))
#for g in engine.optimizer.param_groups:
#g['lr'] = lr
train_loss = []
train_mape = []
train_rmse = []
t1 = time.time()
dataloader['train_loader'].shuffle()
for iter, (x,
y) in enumerate(dataloader['train_loader'].get_iterator()):
trainx = torch.Tensor(x).to(device)
trainx = trainx.transpose(1, 3)
trainy = torch.Tensor(y).to(device)
trainy = trainy.transpose(1, 3)
metrics = engine.train(trainx, trainy[:, 0, :, :])
train_loss.append(metrics[0])
train_mape.append(metrics[1])
train_rmse.append(metrics[2])
if iter % args.print_every == 0:
log = 'Iter: {:03d}, Train Loss: {:.4f}, Train MAPE: {:.4f}, Train RMSE: {:.4f}'
print(log.format(iter, train_loss[-1], train_mape[-1],
train_rmse[-1]),
flush=True)
t2 = time.time()
train_time.append(t2 - t1)
#validation
valid_loss = []
valid_mape = []
valid_rmse = []
s1 = time.time()
for iter, (x, y) in enumerate(dataloader['val_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
testx = testx.transpose(1, 3)
testy = torch.Tensor(y).to(device)
testy = testy.transpose(1, 3)
metrics = engine.eval(testx, testy[:, 0, :, :])
valid_loss.append(metrics[0])
valid_mape.append(metrics[1])
valid_rmse.append(metrics[2])
s2 = time.time()
log = 'Epoch: {:03d}, Inference Time: {:.4f} secs'
print(log.format(i, (s2 - s1)))
val_time.append(s2 - s1)
mtrain_loss = np.mean(train_loss)
mtrain_mape = np.mean(train_mape)
mtrain_rmse = np.mean(train_rmse)
mvalid_loss = np.mean(valid_loss)
mvalid_mape = np.mean(valid_mape)
mvalid_rmse = np.mean(valid_rmse)
his_loss.append(mvalid_loss)
log = 'Epoch: {:03d}, Train Loss: {:.4f}, Train MAPE: {:.4f}, Train RMSE: {:.4f}, Valid Loss: {:.4f}, Valid MAPE: {:.4f}, Valid RMSE: {:.4f}, Training Time: {:.4f}/epoch'
print(log.format(i, mtrain_loss, mtrain_mape, mtrain_rmse, mvalid_loss,
mvalid_mape, mvalid_rmse, (t2 - t1)),
flush=True)
torch.save(
engine.model.state_dict(), args.save + "_epoch_" + str(i) + "_" +
str(round(mvalid_loss, 2)) + ".pth")
print("Average Training Time: {:.4f} secs/epoch".format(
np.mean(train_time)))
print("Average Inference Time: {:.4f} secs".format(np.mean(val_time)))
#testing
bestid = np.argmin(his_loss)
engine.model.load_state_dict(
torch.load(args.save + "_epoch_" + str(bestid + 1) + "_" +
str(round(his_loss[bestid], 2)) + ".pth"))
outputs = []
realy = torch.Tensor(dataloader['y_test']).to(device)
realy = realy.transpose(1, 3)[:, 0, :, :]
for iter, (x, y) in enumerate(dataloader['test_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
testx = testx.transpose(1, 3)
with torch.no_grad():
preds = engine.model(testx).transpose(1, 3)
outputs.append(preds.squeeze())
yhat = torch.cat(outputs, dim=0)
yhat = yhat[:realy.size(0), ...]
print("Training finished")
print("The valid loss on best model is", str(round(his_loss[bestid], 4)))
amae = []
amape = []
armse = []
for i in range(12):
pred = scaler.inverse_transform(yhat[:, :, i])
real = realy[:, :, i]
metrics = util.metric(pred, real)
log = 'Evaluate best model on test data for horizon {:d}, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(i + 1, metrics[0], metrics[1], metrics[2]))
amae.append(metrics[0])
amape.append(metrics[1])
armse.append(metrics[2])
log = 'On average over 12 horizons, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(np.mean(amae), np.mean(amape), np.mean(armse)))
torch.save(
engine.model.state_dict(), args.save + "_exp" + str(args.expid) +
"_best_" + str(round(his_loss[bestid], 2)) + ".pth")
pred = util.re_normalization(out, mean[0], std[0])
label = util.re_normalization(normalization_label, mean[0],
std[0])
loss = criterion(out, y[:, :, :, 0])
val_losses.append(loss.detach().cpu().numpy())
val_pred.append(pred.cpu().detach().numpy())
val_label.append(label)
val_loss = sum(val_losses)
validation_losses.append(val_loss)
val_pred_ = np.concatenate(val_pred, axis=0)
val_label_ = np.concatenate(val_label, axis=0)
val_mae, val_rmse, val_mape, b = util.metric(val_pred_, val_label_)
validation_rmse_set.append(val_rmse)
validation_MAE_set.append(val_mae)
end = process_time()
running_time_set.append(end - start)
if val_rmse < best_val_loss:
stop = 0
best_val_loss = val_rmse
params_filename = osp.join(args.save, 'params')
torch.save(
{
'epoch': epoch,
'model_state_dict': net.state_dict(),
'opt_state_dict': optimizer.state_dict(),
def main():
#set seed
#torch.manual_seed(args.seed)
#np.random.seed(args.seed)
#load data
device = torch.device(args.device)
sensor_ids, sensor_id_to_ind, adj_mx = util.load_adj(
args.adjdata, args.adjtype)
dataloader = util.load_dataset(args.data, args.batch_size, args.batch_size,
args.batch_size)
#scaler = dataloader['scaler']
supports = [torch.tensor(i).to(device) for i in adj_mx]
print(args)
if args.model == 'gwnet':
engine = trainer1(args.in_dim, args.seq_length, args.num_nodes,
args.nhid, args.dropout, args.learning_rate,
args.weight_decay, device, supports, args.decay)
elif args.model == 'ASTGCN_Recent':
engine = trainer2(args.in_dim, args.seq_length, args.num_nodes,
args.nhid, args.dropout, args.learning_rate,
args.weight_decay, device, supports, args.decay)
elif args.model == 'GRCN':
engine = trainer3(args.in_dim, args.seq_length, args.num_nodes,
args.nhid, args.dropout, args.learning_rate,
args.weight_decay, device, supports, args.decay)
elif args.model == 'Gated_STGCN':
engine = trainer4(args.in_dim, args.seq_length, args.num_nodes,
args.nhid, args.dropout, args.learning_rate,
args.weight_decay, device, supports, args.decay)
elif args.model == 'H_GCN_wh':
engine = trainer5(args.in_dim, args.seq_length, args.num_nodes,
args.nhid, args.dropout, args.learning_rate,
args.weight_decay, device, supports, args.decay)
elif args.model == 'OGCRNN':
engine = trainer8(args.in_dim, args.seq_length, args.num_nodes,
args.nhid, args.dropout, args.learning_rate,
args.weight_decay, device, supports, args.decay)
elif args.model == 'OTSGGCN':
engine = trainer9(args.in_dim, args.seq_length, args.num_nodes,
args.nhid, args.dropout, args.learning_rate,
args.weight_decay, device, supports, args.decay)
elif args.model == 'LSTM':
engine = trainer10(args.in_dim, args.seq_length, args.num_nodes,
args.nhid, args.dropout, args.learning_rate,
args.weight_decay, device, supports, args.decay)
elif args.model == 'GRU':
engine = trainer11(args.in_dim, args.seq_length, args.num_nodes,
args.nhid, args.dropout, args.learning_rate,
args.weight_decay, device, supports, args.decay)
# check parameters file
params_path = args.save + "/" + args.model
if os.path.exists(params_path) and not args.force:
raise SystemExit(
"Params folder exists! Select a new params path please!")
else:
if os.path.exists(params_path):
shutil.rmtree(params_path)
os.makedirs(params_path)
print('Create params directory %s' % (params_path))
print("start training...", flush=True)
his_loss = []
val_time = []
train_time = []
for i in range(1, args.epochs + 1):
#if i % 10 == 0:
#lr = max(0.000002,args.learning_rate * (0.1 ** (i // 10)))
#for g in engine.optimizer.param_groups:
#g['lr'] = lr
train_loss = []
train_mae = []
train_mape = []
train_rmse = []
t1 = time.time()
dataloader['train_loader'].shuffle()
for iter, (x,
y) in enumerate(dataloader['train_loader'].get_iterator()):
trainx = torch.Tensor(x).to(device)
trainx = trainx.transpose(1, 3)
trainy = torch.Tensor(y).to(device)
trainy = trainy.transpose(1, 3)
metrics = engine.train(trainx, trainy[:, 0, :, :])
train_loss.append(metrics[0])
train_mae.append(metrics[1])
train_mape.append(metrics[2])
train_rmse.append(metrics[3])
#if iter % args.print_every == 0 :
# log = 'Iter: {:03d}, Train Loss: {:.4f}, Train MAPE: {:.4f}, Train RMSE: {:.4f}'
# print(log.format(iter, train_loss[-1], train_mape[-1], train_rmse[-1]),flush=True)
t2 = time.time()
train_time.append(t2 - t1)
#validation
valid_loss = []
valid_mae = []
valid_mape = []
valid_rmse = []
s1 = time.time()
for iter, (x, y) in enumerate(dataloader['val_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
testx = testx.transpose(1, 3)
testy = torch.Tensor(y).to(device)
testy = testy.transpose(1, 3)
metrics = engine.eval(testx, testy[:, 0, :, :])
valid_loss.append(metrics[0])
valid_mae.append(metrics[1])
valid_mape.append(metrics[2])
valid_rmse.append(metrics[3])
s2 = time.time()
log = 'Epoch: {:03d}, Inference Time: {:.4f} secs'
print(log.format(i, (s2 - s1)))
val_time.append(s2 - s1)
mtrain_loss = np.mean(train_loss)
mtrain_mae = np.mean(train_mae)
mtrain_mape = np.mean(train_mape)
mtrain_rmse = np.mean(train_rmse)
mvalid_loss = np.mean(valid_loss)
mvalid_mae = np.mean(valid_mae)
mvalid_mape = np.mean(valid_mape)
mvalid_rmse = np.mean(valid_rmse)
his_loss.append(mvalid_loss)
log = 'Epoch: {:03d}, Train Loss: {:.4f}, Train MAE: {:.4f}, Train MAPE: {:.4f}, Train RMSE: {:.4f}, Valid Loss: {:.4f}, Valid MAE: {:.4f}, Valid MAPE: {:.4f}, Valid RMSE: {:.4f}, Training Time: {:.4f}/epoch'
print(log.format(i, mtrain_loss, mtrain_mae, mtrain_mape, mtrain_rmse,
mvalid_loss, mvalid_mae, mvalid_mape, mvalid_rmse,
(t2 - t1)),
flush=True)
torch.save(
engine.model.state_dict(), params_path + "/" + args.model +
"_epoch_" + str(i) + "_" + str(round(mvalid_loss, 2)) + ".pth")
print("Average Training Time: {:.4f} secs/epoch".format(
np.mean(train_time)))
print("Average Inference Time: {:.4f} secs".format(np.mean(val_time)))
#testing
bestid = np.argmin(his_loss)
engine.model.load_state_dict(
torch.load(params_path + "/" + args.model + "_epoch_" +
str(bestid + 1) + "_" + str(round(his_loss[bestid], 2)) +
".pth"))
engine.model.eval()
outputs = []
realy = torch.Tensor(dataloader['y_test']).to(device)
realy = realy.transpose(1, 3)[:, 0, :, :]
for iter, (x, y) in enumerate(dataloader['test_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
testx = testx.transpose(1, 3)
with torch.no_grad():
preds, spatial_at, parameter_adj = engine.model(testx)
preds = preds.transpose(1, 3)
outputs.append(preds.squeeze())
yhat = torch.cat(outputs, dim=0)
yhat = yhat[:realy.size(0), ...]
print("Training finished")
print("The valid loss on best model is", str(round(his_loss[bestid], 4)))
amae = []
amape = []
armse = []
prediction = yhat
for i in range(12):
pred = prediction[:, :, i]
#pred = scaler.inverse_transform(yhat[:,:,i])
#prediction.append(pred)
real = realy[:, :, i]
metrics = util.metric(pred, real)
log = 'Evaluate best model on test data for horizon {:d}, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(i + 1, metrics[0], metrics[1], metrics[2]))
amae.append(metrics[0])
amape.append(metrics[1])
armse.append(metrics[2])
log = 'On average over 12 horizons, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(np.mean(amae), np.mean(amape), np.mean(armse)))
torch.save(
engine.model.state_dict(), params_path + "/" + args.model + "_exp" +
str(args.expid) + "_best_" + str(round(his_loss[bestid], 2)) + ".pth")
prediction_path = params_path + "/" + args.model + "_prediction_results"
ground_truth = realy.cpu().detach().numpy()
prediction = prediction.cpu().detach().numpy()
spatial_at = spatial_at.cpu().detach().numpy()
parameter_adj = parameter_adj.cpu().detach().numpy()
np.savez_compressed(os.path.normpath(prediction_path),
prediction=prediction,
spatial_at=spatial_at,
parameter_adj=parameter_adj,
ground_truth=ground_truth)
def main():
frequencies = np.array([
8.176, 8.662, 9.177, 9.723, 10.301, 10.913, 11.562, 12.250, 12.978,
13.750, 14.568, 15.434, 16.352, 17.324, 18.354, 19.445, 20.601, 21.826,
23.124, 24.499, 25.956, 27.500, 29.135, 30.867, 32.703, 34.648, 36.708,
38.890, 41.203, 43.653, 46.249, 48.999, 51.913, 55.000, 58.270, 61.735,
65.406, 69.295, 73.416, 77.781, 82.406, 87.307, 92.499, 97.998, 103.82,
110.00, 116.54, 123.47, 130.81, 138.59, 146.83, 155.56, 164.81, 174.61,
184.99, 195.99, 207.65, 220.00, 233.08, 246.94, 261.63, 277.18, 293.66,
311.13, 329.63, 349.23, 369.99, 391.99, 415.31, 440.00, 466.16, 439.88,
523.25, 554.37, 587.33, 622.25, 659.26, 698.46, 739.99, 783.99, 830.61,
880.00, 932.32, 987.77, 1046.5, 1108.7, 1174.7, 1244.5, 1318.5, 1396.9,
1480.0, 1568.0, 1661.2, 1760.0, 1864.7, 1975.5, 2093.0, 2217.5, 2349.3,
2489.0, 2637.0, 2793.8, 2960.0, 3136.0, 3322.4, 3520.0, 3729.3, 3951.1,
4186.0, 4434.9, 4698.6, 4978.0, 5274.0, 5587.7, 5919.9, 6271.9, 6644.9,
7040.0, 7458.6, 7902.1, 8372.0, 8869.8, 9397.3, 9956.1, 10548.1,
11175.3, 11839.8, 12543.9
])
piano_adj = np.zeros((128, 128))
for row in range(128):
piano_adj[row] = frequencies - frequencies[row]
device = torch.device(args.device)
adj_mx = util.load_piano_adj(piano_adj, args.adjtype)
supports = [torch.tensor(i).to(device) for i in adj_mx]
if args.randomadj:
adjinit = None
else:
adjinit = supports[0]
if args.aptonly:
supports = None
model = gwnet(device,
args.num_nodes,
args.dropout,
supports=supports,
gcn_bool=args.gcn_bool,
addaptadj=args.addaptadj,
aptinit=adjinit,
in_dim=args.in_dim,
out_dim=args.seq_length,
residual_channels=args.nhid,
dilation_channels=args.nhid,
skip_channels=args.nhid * 8,
end_channels=args.nhid * 16)
model.to(device)
model.load_state_dict(torch.load(args.checkpoint))
model.eval()
print('model load successfully')
dataloader = util.load_dataset(args.data, args.batch_size, args.batch_size,
args.batch_size)
scaler = dataloader['scaler']
outputs = []
realy = torch.Tensor(dataloader['y_test']).to(device)
realy = realy.transpose(1, 3)[:, 0, :, :]
for iter, (x, y) in enumerate(dataloader['test_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
# print(x.shape)
testx = testx.transpose(1, 3)
# print(x.shape)
with torch.no_grad():
preds = model(testx).transpose(1, 3)
# print(preds.shape)
outputs.append(preds.squeeze())
break
# print(len(outputs))
# print(outputs[0].shape)
yhat = torch.cat(outputs, dim=0)
# print(yhat.shape)
yhat = yhat[:realy.size(0), ...]
# print(yhat.shape)
amae = []
amape = []
armse = []
for i in range(12):
pred = scaler.inverse_transform(yhat[:, :, i])
# print(pred.shape)
# time.sleep(1)
# print("asdf" + 234)
real = realy[:, :, i]
metrics = util.metric(pred, real)
log = 'Evaluate best model on test data for horizon {:d}, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(i + 1, metrics[0], metrics[1], metrics[2]))
amae.append(metrics[0])
amape.append(metrics[1])
armse.append(metrics[2])
log = 'On average over 12 horizons, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(np.mean(amae), np.mean(amape), np.mean(armse)))
if args.plotheatmap == "True":
adp = F.softmax(F.relu(torch.mm(model.nodevec1, model.nodevec2)),
dim=1)
device = torch.device('cpu')
adp.to(device)
adp = adp.cpu().detach().numpy()
adp = adp * (1 / np.max(adp))
df = pd.DataFrame(adp)
sns.heatmap(df, cmap="RdYlBu")
plt.savefig("./emb" + '.pdf')
y12 = realy[:, 99, 11].cpu().detach().numpy()
yhat12 = scaler.inverse_transform(yhat[:, 99, 11]).cpu().detach().numpy()
y3 = realy[:, 99, 2].cpu().detach().numpy()
yhat3 = scaler.inverse_transform(yhat[:, 99, 2]).cpu().detach().numpy()
df2 = pd.DataFrame({
'real12': y12,
'pred12': yhat12,
'real3': y3,
'pred3': yhat3
})
df2.to_csv('./wave.csv', index=False)
def main():
#set seed
args.seed = args.seed if args.seed else \
np.random.randint(0, np.iinfo("uint32").max, size=1)[-1]
torch.manual_seed(args.seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
np.random.seed(args.seed)
# update run_name & save_dir
args.run_name += "_".join(
[args.data_type, str(args.seq_length),
str(args.seed)])
args.save += args.run_name + "/"
os.makedirs(args.save)
wandb.init(config=args, project=args.project_name, name=args.run_name)
#load data
device = torch.device(args.device)
sensor_ids, sensor_id_to_ind, adj_mx = util.load_adj(
args.adjdata, args.adjtype)
dataloader = util.load_dataset(args.data, args.batch_size, args.batch_size,
args.batch_size)
scaler = dataloader['scaler']
supports = [torch.tensor(i).to(device) for i in adj_mx]
print(args)
if args.randomadj:
adjinit = None
else:
adjinit = supports[0]
if args.aptonly:
supports = None
engine = trainer(scaler, args.in_dim, args.seq_length, args.num_nodes,
args.nhid, args.dropout, args.learning_rate,
args.weight_decay, device, supports, args.gcn_bool,
args.addaptadj, adjinit, args.impute_type)
print("start training...", flush=True)
his_loss = []
val_time = []
train_time = []
for i in tqdm(range(1, args.epochs + 1)):
train_loss = []
train_mape = []
train_rmse = []
t1 = time.time()
if i > 1:
# Skip shuffling for 1st epoch for data imputation
dataloader['train_loader'].shuffle()
for iter, (x,
y) in enumerate(dataloader['train_loader'].get_iterator()):
if i == 1 or engine.imputer.type == "GCN":
trainx = engine.imputer(x.transpose(1, 3),
engine.model.get_supports())
else:
trainx = x.transpose(1, 3)
trainx = trainx.to(device)
trainy = torch.Tensor(y).to(device)
trainy = trainy.transpose(1, 3)
metrics = engine.train(trainx, trainy[:, 0, :, :])
train_loss.append(metrics[0])
train_mape.append(metrics[1])
train_rmse.append(metrics[2])
if iter % args.print_every == 0:
log = 'Iter: {:03d}, Train Loss: {:.4f}, Train MAPE: {:.4f}, Train RMSE: {:.4f}'
print(log.format(iter, train_loss[-1], train_mape[-1],
train_rmse[-1]),
flush=True)
t2 = time.time()
train_time.append(t2 - t1)
#validation
valid_loss = []
valid_mape = []
valid_rmse = []
s1 = time.time()
for iter, (x, y) in enumerate(dataloader['val_loader'].get_iterator()):
if i == 1 or engine.imputer.type == "GCN":
testx = engine.imputer(x.transpose(1, 3),
engine.model.get_supports())
else:
testx = x.transpose(1, 3)
testx = testx.to(device)
testy = torch.Tensor(y).to(device)
testy = testy.transpose(1, 3)
metrics = engine.eval(testx, testy[:, 0, :, :])
valid_loss.append(metrics[0])
valid_mape.append(metrics[1])
valid_rmse.append(metrics[2])
s2 = time.time()
log = 'Epoch: {:03d}, Inference Time: {:.4f} secs'
print(log.format(i, (s2 - s1)))
val_time.append(s2 - s1)
mtrain_loss = np.mean(train_loss)
mtrain_mape = np.mean(train_mape)
mtrain_rmse = np.mean(train_rmse)
mvalid_loss = np.mean(valid_loss)
mvalid_mape = np.mean(valid_mape)
mvalid_rmse = np.mean(valid_rmse)
his_loss.append(mvalid_loss)
log = 'Epoch: {:03d}, Train Loss: {:.4f}, Train MAPE: {:.4f}, Train RMSE: {:.4f}, Valid Loss: {:.4f}, Valid MAPE: {:.4f}, Valid RMSE: {:.4f}, Training Time: {:.4f}/epoch'
print(log.format(i, mtrain_loss, mtrain_mape, mtrain_rmse, mvalid_loss,
mvalid_mape, mvalid_rmse, (t2 - t1)),
flush=True)
torch.save(
engine.model.state_dict(), args.save + "epoch_" + str(i) + "_" +
str(round(mvalid_loss, 2)) + ".pth")
wandb.log(
{
"Train MAE": mtrain_loss,
"Train MAPE": mtrain_mape,
"Train RMSE": mtrain_rmse,
"Validation MAE": mvalid_loss,
"Validation MAPE": mvalid_mape,
"Validation RMSE": mvalid_rmse
},
step=i)
print("Average Training Time: {:.4f} secs/epoch".format(
np.mean(train_time)))
print("Average Inference Time: {:.4f} secs".format(np.mean(val_time)))
#testing
bestid = np.argmin(his_loss)
engine.model.load_state_dict(
torch.load(args.save + "epoch_" + str(bestid + 1) + "_" +
str(round(his_loss[bestid], 2)) + ".pth"))
outputs = []
realy = torch.Tensor(dataloader['y_test']).to(device)
realy = realy.transpose(1, 3)[:, 0, :, :]
for iter, (x, y) in enumerate(dataloader['test_loader'].get_iterator()):
with torch.no_grad():
testx = engine.imputer(x.transpose(1, 3),
engine.model.get_supports())
testx = testx.to(device)
preds = engine.model(testx).transpose(1, 3)
outputs.append(preds.squeeze(1))
yhat = torch.cat(outputs, dim=0)
yhat = yhat[:realy.size(0), ...]
print("Training finished")
print("The valid loss on best model is", str(round(his_loss[bestid], 4)))
amae = []
amape = []
armse = []
for i in range(args.seq_length):
pred = scaler.inverse_transform(yhat[:, :, i])
real = realy[:, :, i]
metrics = util.metric(pred, real)
log = 'Evaluate best model on test data for horizon {:d}, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(i + 1, metrics[0], metrics[1], metrics[2]))
amae.append(metrics[0])
amape.append(metrics[1])
armse.append(metrics[2])
wandb.log(
{
"Test MAE": metrics[0],
"Test MAPE": metrics[1],
"Test RMSE": metrics[2]
},
step=i + args.epochs + 1)
log = 'On average over horizons, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(np.mean(amae), np.mean(amape), np.mean(armse)))
wandb.log({
"Avg Test MAE": np.mean(amae),
"Avg Test MAPE": np.mean(amape),
"Avg Test RMSE": np.mean(armse)
})
torch.save(engine.model.state_dict(),
args.save + "best_" + str(round(his_loss[bestid], 2)) + ".pth")
def main():
#load data
device = torch.device(args.device)
sensor_ids, sensor_id_to_ind, adj_mx = util.load_adj(
args.adjdata, args.adjtype)
sensor_ids_cluster, sensor_id_to_ind_cluster, adj_mx_cluster = util.load_adj(
args.adjdatacluster, args.adjtype)
dataloader = util.load_dataset_cluster(args.data, args.batch_size,
args.batch_size, args.batch_size)
#scaler = dataloader['scaler']
supports = [torch.tensor(i).to(device) for i in adj_mx]
supports_cluster = [torch.tensor(i).to(device) for i in adj_mx_cluster]
transmit_np = np.float32(np.loadtxt(args.transmit, delimiter=','))
transmit = torch.tensor(transmit_np).to(device)
print(args)
if args.model == 'H_GCN':
engine = trainer7(args.in_dim, args.in_dim_cluster, args.seq_length,
args.num_nodes, args.cluster_nodes, args.nhid,
args.dropout, args.learning_rate, args.weight_decay,
device, supports, supports_cluster, transmit,
args.decay)
elif args.model == 'H_GCN_wdf':
engine = trainer6(args.in_dim, args.in_dim_cluster, args.seq_length,
args.num_nodes, args.cluster_nodes, args.nhid,
args.dropout, args.learning_rate, args.weight_decay,
device, supports, supports_cluster, transmit,
args.decay)
# check parameters file
params_path = args.save + "/" + args.model
if os.path.exists(params_path) and not args.force:
raise SystemExit(
"Params folder exists! Select a new params path please!")
else:
if os.path.exists(params_path):
shutil.rmtree(params_path)
os.makedirs(params_path)
print('Create params directory %s' % (params_path))
print("start training...", flush=True)
his_loss = []
val_time = []
train_time = []
for i in range(1, args.epochs + 1):
train_loss = []
train_mae = []
train_mape = []
train_rmse = []
t1 = time.time()
dataloader['train_loader_cluster'].shuffle()
for iter, (x, y, x_cluster, y_cluster) in enumerate(
dataloader['train_loader_cluster'].get_iterator()):
trainx = torch.Tensor(x).to(device)
trainx = trainx.transpose(1, 3)
trainy = torch.Tensor(y).to(device)
trainy = trainy.transpose(1, 3)
trainx_cluster = torch.Tensor(x_cluster).to(device)
trainx_cluster = trainx_cluster.transpose(1, 3)
trainy_cluster = torch.Tensor(y_cluster).to(device)
trainy_cluster = trainy_cluster.transpose(1, 3)
metrics = engine.train(trainx, trainx_cluster, trainy[:, 0, :, :],
trainy_cluster)
train_loss.append(metrics[0])
train_mae.append(metrics[1])
train_mape.append(metrics[2])
train_rmse.append(metrics[3])
#engine.scheduler.step()
t2 = time.time()
train_time.append(t2 - t1)
#validation
valid_loss = []
valid_mae = []
valid_mape = []
valid_rmse = []
s1 = time.time()
for iter, (x, y, x_cluster, y_cluster) in enumerate(
dataloader['val_loader_cluster'].get_iterator()):
validx = torch.Tensor(x).to(device)
validx = validx.transpose(1, 3)
validy = torch.Tensor(y).to(device)
validy = validy.transpose(1, 3)
validx_cluster = torch.Tensor(x_cluster).to(device)
validx_cluster = validx_cluster.transpose(1, 3)
validy_cluster = torch.Tensor(y_cluster).to(device)
validy_cluster = validy_cluster.transpose(1, 3)
metrics = engine.eval(validx, validx_cluster, validy[:, 0, :, :],
validy_cluster)
valid_loss.append(metrics[0])
valid_mae.append(metrics[1])
valid_mape.append(metrics[2])
valid_rmse.append(metrics[3])
s2 = time.time()
log = 'Epoch: {:03d}, Inference Time: {:.4f} secs'
print(log.format(i, (s2 - s1)))
val_time.append(s2 - s1)
mtrain_loss = np.mean(train_loss)
mtrain_mae = np.mean(train_mae)
mtrain_mape = np.mean(train_mape)
mtrain_rmse = np.mean(train_rmse)
mvalid_loss = np.mean(valid_loss)
mvalid_mae = np.mean(valid_mae)
mvalid_mape = np.mean(valid_mape)
mvalid_rmse = np.mean(valid_rmse)
his_loss.append(mvalid_loss)
log = 'Epoch: {:03d}, Train Loss: {:.4f}, Train MAE: {:.4f}, Train MAPE: {:.4f}, Train RMSE: {:.4f}, Valid Loss: {:.4f}, Valid MAE: {:.4f}, Valid MAPE: {:.4f}, Valid RMSE: {:.4f}, Training Time: {:.4f}/epoch'
print(log.format(i, mtrain_loss, mtrain_mae, mtrain_mape, mtrain_rmse,
mvalid_loss, mvalid_mae, mvalid_mape, mvalid_rmse,
(t2 - t1)),
flush=True)
torch.save(
engine.model.state_dict(), params_path + "/" + args.model +
"_epoch_" + str(i) + "_" + str(round(mvalid_loss, 2)) + ".pth")
print("Average Training Time: {:.4f} secs/epoch".format(
np.mean(train_time)))
print("Average Inference Time: {:.4f} secs".format(np.mean(val_time)))
#testing
bestid = np.argmin(his_loss)
engine.model.load_state_dict(
torch.load(params_path + "/" + args.model + "_epoch_" +
str(bestid + 1) + "_" + str(round(his_loss[bestid], 2)) +
".pth"))
engine.model.eval()
outputs = []
realy = torch.Tensor(dataloader['y_test']).to(device)
realy = realy.transpose(1, 3)[:, 0, :, :]
#print(realy.shape)
for iter, (x, y, x_cluster, y_cluster) in enumerate(
dataloader['test_loader_cluster'].get_iterator()):
testx = torch.Tensor(x).to(device)
testx = testx.transpose(1, 3)
testx_cluster = torch.Tensor(x_cluster).to(device)
testx_cluster = testx_cluster.transpose(1, 3)
with torch.no_grad():
preds, _, _ = engine.model(testx, testx_cluster)
preds = preds.transpose(1, 3)
outputs.append(preds.squeeze())
for iter, (x, y, x_cluster, y_cluster) in enumerate(
dataloader['test_loader_cluster'].get_iterator()):
testx = torch.Tensor(x).to(device)
testx = testx.transpose(1, 3)
testx_cluster = torch.Tensor(x_cluster).to(device)
testx_cluster = testx_cluster.transpose(1, 3)
with torch.no_grad():
_, spatial_at, parameter_adj = engine.model(testx, testx_cluster)
break
yhat = torch.cat(outputs, dim=0)
yhat = yhat[:realy.size(0), ...]
#print(yhat.shape)
print("Training finished")
print("The valid loss on best model is", str(round(his_loss[bestid], 4)))
amae = []
amape = []
armse = []
prediction = yhat
for i in range(12):
pred = prediction[:, :, i]
#pred = scaler.inverse_transform(yhat[:,:,i])
#prediction.append(pred)
real = realy[:, :, i]
metrics = util.metric(pred, real)
log = 'Evaluate best model on test data for horizon {:d}, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(i + 1, metrics[0], metrics[1], metrics[2]))
amae.append(metrics[0])
amape.append(metrics[1])
armse.append(metrics[2])
log = 'On average over 12 horizons, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(np.mean(amae), np.mean(amape), np.mean(armse)))
torch.save(
engine.model.state_dict(), params_path + "/" + args.model + "_exp" +
str(args.expid) + "_best_" + str(round(his_loss[bestid], 2)) + ".pth")
prediction_path = params_path + "/" + args.model + "_prediction_results"
ground_truth = realy.cpu().detach().numpy()
prediction = prediction.cpu().detach().numpy()
spatial_at = spatial_at.cpu().detach().numpy()
parameter_adj = parameter_adj.cpu().detach().numpy()
np.savez_compressed(os.path.normpath(prediction_path),
prediction=prediction,
spatial_at=spatial_at,
parameter_adj=parameter_adj,
ground_truth=ground_truth)
def busy(agi):
util.metric(agi, 'friction-busy')
agi.appexec('busy')
def delay_5(agi):
util.metric(agi, 'delay-5')
agi.appexec('wait', 5)
def delay_10(agi):
util.metric(agi, 'friction-delay-10')
agi.appexec('wait', 5)
agi.appexec('MusicOnHold', ',5')
def delay_5(agi):
util.metric(agi, 'friction-delay-5')
agi.appexec('wait', 5)
def gh_linkscan(bot, url):
try:
if not re.match("http(s)?://github.com", url):
bot._debug("I don't know what %s is..." % url)
return None
gh = gh_inst(bot)
if isinstance(gh, basestring):
bot._debug("Error: %s" % gh)
return gh
r_repo = "^https?://github.com/([A-Za-z0-9-]+)/([A-Za-z0-9-\.]+)"
r_commit = "^https?://github.com/[A-Za-z0-9-]+/[A-Za-z0-9-\.]+/commit/([A-Za-z0-9]+)"
r_blob = "^https?://github.com/[A-Za-z0-9-]+/[A-Za-z0-9-\.]+/blob/([A-Za-z0-9]+)/(.*)"
r_tree = "^https?://github.com/[A-Za-z0-9-]+/[A-Za-z0-9-\.]+/tree/([A-Za-z0-9]+)/(.*)"
r_issue = "^https?://github.com/[A-Za-z0-9-]+/[A-Za-z0-9-\.]+/(issues|pull)/(\d+)"
r = re.match(r_repo, url)
if not r:
return None
repo = "%s/%s" % r.group(1, 2)
ghrepo = gh.get_repo(repo)
bot._debug("Repo: %s" % repo)
commit = re.match(r_commit, url)
blob = re.match(r_blob, url)
tree = re.match(r_tree, url)
issue = re.match(r_issue, url)
if commit:
bot._debug("Commit SHA: %s" % commit.group(1))
commit = ghrepo.get_commit(commit.group(1))
fmt = "GitHub: \x02%s\x0f commit \x02%s\x0f: %s [/%s] [\x033+%s\x0f \x035-%s\x0f]" % (repo, commit.sha[:8], commit.commit.message, commit.author.login, util.metric(commit.stats.additions), util.metric(commit.stats.deletions))
return fmt.encode('utf-8')
elif blob:
bot._debug("Blob: [%s] %s" % blob.group(1, 2))
ref = blob.group(1)
blob = ghrepo.get_contents(path=blob.group(2), ref=ref)
fmt = "GitHub: \x02%s\x0f file \x02%s\x0f [%s, branch %s]" % (repo, blob.name, util.metric(blob.size), ref)
return fmt.encode('utf-8')
elif tree:
bot._debug("Tree: [%s] %s" % tree.group(1, 2))
ref, path = tree.group(1, 2)
tree = ghrepo.get_dir_contents(path=path, ref=ref)
fmt = "GitHub: \x02%s\x0f dir \x02%s\x0f [%s files, branch %s]" % (repo, path, util.metric(len(tree)), ref)
return fmt.encode('utf-8')
elif issue:
id = issue.group(2)
bot._debug("Issue ID: #%s" % id)
issue = ghrepo.get_issue(int(id))
assigned_to = issue.assignee.login if issue.assignee else 'no one'
if issue.state == "open":
fmt = "GitHub: \x02%s\x0f issue \x02#%s\x0f: %s [by %s, %s assigned, created %s, updated %s]" % (repo, id, issue.title, issue.user.login, assigned_to, util.pretty_date(issue.created_at), util.pretty_date(issue.updated_at))
else:
fmt = "GitHub: \x02%s\x0f issue \x02#%s\x0f: %s [by %s, \x035closed\x0f by %s %s]" % (repo, id, issue.title, issue.user.login, issue.closed_by.login, util.pretty_date(issue.closed_at))
return fmt.encode('utf-8')
else:
forks = str(ghrepo.forks)
watchers = str(ghrepo.watchers)
fmt = "GitHub: \x02%s\x0f [%sf %sw] last updated %s" % (repo, forks, watchers, util.pretty_date(ghrepo.pushed_at))
return fmt.encode('utf-8')
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout)
raise
def context_restricted_dialtone(agi):
util.metric(agi, 'friction-context-restricted-dialtone')
agi.set_context('restricted-outgoing-dialtone-wrapper')
agi.set_extension('s')
agi.set_priority(1)
sm = SMOTE(random_state=1)
X_train_res, y_train_res = sm.fit_resample(X_train, y_train)
# Scaling the the training set
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_train_res)
# Fit the data to the model
model = SVC_Classification()
model.fit(X_scaled, y_train_res)
# Save the fitted model
with open("models/svc_model.pkl", "wb") as m:
pickle.dump(model, m)
# Save the fitted scaler
with open("models/svc_scaler.pkl", "wb") as s:
pickle.dump(scaler, s)
with open("models/svc_model.pkl", "rb") as m:
model = pickle.load(m)
with open("models/svc_scaler.pkl", "rb") as s:
scaler = pickle.load(s)
X_test_scaled = scaler.transform(X_test)
y_pred = model.predict_label(X_test_scaled)
precision, recall, accuracy, matrix = metric(y_test, y_pred)
print(matrix)
print("Recall: {}".format(round(recall, 2)))
print("Precision: {}".format(round(precision, 2)))
def busy(agi):
util.metric(agi, 'friction-busy')
agi.appexec('busy')
def main():
# set seed
torch.manual_seed(args.seed)
np.random.seed(args.seed)
# load data
device = torch.device(args.device)
sensor_ids, sensor_id_to_ind, adj_mx = util.load_adj(
args.adjdata, args.adjtype)
# suffix = '_filtered_we' # _filtered_we, _filtered_ew
eR_seq_size = 24 # 24
error_size = 6
dataloader = util.load_dataset(args.data,
args.batch_size,
args.batch_size,
args.batch_size,
eRec=args.eRec,
eR_seq_size=eR_seq_size,
suffix=args.suffix)
scaler = dataloader['scaler']
if args.retrain:
dl_train = util.load_dataset(args.data,
args.batch_size,
args.batch_size,
args.batch_size,
eRec=args.eRec,
eR_seq_size=eR_seq_size,
suffix=args.suffix_train)
scaler = dl_train['scaler']
blocks = int(dataloader[f'x_train{args.suffix}'].shape[-3] /
3) # Every block reduce the input sequence size by 3.
print(f'blocks = {blocks}')
supports = [torch.tensor(i).to(device) for i in adj_mx]
print(args)
if args.randomadj:
adjinit = None
else:
adjinit = supports[0]
if args.aptonly:
supports = None
engine = trainer(scaler,
args.in_dim,
args.seq_length,
args.num_nodes,
args.nhid,
args.dropout,
args.learning_rate,
args.weight_decay,
device,
supports,
args.gcn_bool,
args.addaptadj,
adjinit,
blocks,
eRec=args.eRec,
retrain=args.retrain,
checkpoint=args.checkpoint,
error_size=error_size)
if args.retrain:
dataloader['val_loader'] = dataloader['train_loader']
print("start training...", flush=True)
his_loss = []
val_time = []
train_time = []
for i in range(1, args.epochs + 1):
#if i % 10 == 0:
#lr = max(0.000002,args.learning_rate * (0.1 ** (i // 10)))
#for g in engine.optimizer.param_groups:
#g['lr'] = lr
train_loss = []
train_mape = []
train_rmse = []
t1 = time.time()
dataloader['train_loader'].shuffle()
for iter, (x,
y) in enumerate(dataloader['train_loader'].get_iterator()):
trainx = torch.Tensor(x).to(device)
trainy = torch.Tensor(y).to(device)
if args.eRec:
trainx = trainx.transpose(0, 1)
trainy = trainy.transpose(0, 1)
trainx = trainx.transpose(-3, -1)
trainy = trainy.transpose(-3, -1)
# print(f'trainx.shape = {trainx.shape}')
# print(f'trainy.shape = {trainy.shape}')
# print(f'trainy.shape final = {trainy[:,0,:,:].shape}')
if args.eRec:
metrics = engine.train(trainx, trainy[:, :, 0, :, :])
else:
metrics = engine.train(trainx, trainy[:, 0, :, :])
train_loss.append(metrics[0])
train_mape.append(metrics[1])
train_rmse.append(metrics[2])
if iter % args.print_every == 0:
log = 'Iter: {:03d}, Train Loss: {:.4f}, Train MAPE: {:.4f}, Train RMSE: {:.4f}'
print(log.format(iter, train_loss[-1], train_mape[-1],
train_rmse[-1]),
flush=True)
t2 = time.time()
train_time.append(t2 - t1)
#validation
valid_loss = []
valid_mape = []
valid_rmse = []
s1 = time.time()
for iter, (x, y) in enumerate(dataloader['val_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
testy = torch.Tensor(y).to(device)
if args.eRec:
testx = testx.transpose(0, 1)
testy = testy.transpose(0, 1)
testx = testx.transpose(-3, -1)
testy = testy.transpose(-3, -1)
if args.eRec:
metrics = engine.eval(testx, testy[:, :, 0, :, :])
else:
metrics = engine.eval(testx, testy[:, 0, :, :])
valid_loss.append(metrics[0])
valid_mape.append(metrics[1])
valid_rmse.append(metrics[2])
s2 = time.time()
log = 'Epoch: {:03d}, Inference Time: {:.4f} secs'
print(log.format(i, (s2 - s1)))
val_time.append(s2 - s1)
mtrain_loss = np.mean(train_loss)
mtrain_mape = np.mean(train_mape)
mtrain_rmse = np.mean(train_rmse)
mvalid_loss = np.mean(valid_loss)
mvalid_mape = np.mean(valid_mape)
mvalid_rmse = np.mean(valid_rmse)
his_loss.append(mvalid_loss)
log = 'Epoch: {:03d}, Train Loss: {:.4f}, Train MAPE: {:.4f}, Train RMSE: {:.4f}, Valid Loss: {:.4f}, Valid MAPE: {:.4f}, Valid RMSE: {:.4f}, Training Time: {:.4f}/epoch'
print(log.format(i, mtrain_loss, mtrain_mape, mtrain_rmse, mvalid_loss,
mvalid_mape, mvalid_rmse, (t2 - t1)),
flush=True)
torch.save(
engine.model.state_dict(), args.save + "_epoch_" + str(i) + "_" +
str(round(mvalid_loss, 2)) + ".pth")
print("Average Training Time: {:.4f} secs/epoch".format(
np.mean(train_time)))
print("Average Inference Time: {:.4f} secs".format(np.mean(val_time)))
#testing
bestid = 82 # 24 hay que sumarle 1 para obtener el ID del modelo
bestid = np.argmin(his_loss)
engine.model.load_state_dict(
torch.load(args.save + "_epoch_" + str(bestid + 1) + "_" +
str(round(his_loss[bestid], 2)) + ".pth"))
# engine.model.load_state_dict(torch.load(args.save + f"_id_25_2.6_best_model.pth"))
# engine.model.load_state_dict(torch.load(args.save + f"_exp1_best_2.6.pth"))
#torch.save(engine.model.state_dict(), args.save + f"_id_{bestid+1}_best_model.pth")
print(f'best_id = {bestid+1}')
outputs = []
realy = torch.Tensor(dataloader[f'y_test{args.suffix}']).to(device)
#print(f'realy: {realy.shape}')
if args.eRec:
realy = realy.transpose(0, 1)
realy = realy.transpose(-3, -1)[-1, :, 0, :, :]
#print(f'realy2: {realy.shape}')
else:
realy = realy.transpose(-3, -1)[:, 0, :, :]
#print(f'realy2: {realy.shape}')
criterion = nn.MSELoss(reduction='none') # L2 Norm
criterion2 = nn.L1Loss(reduction='none')
loss_mse_list = []
loss_mae_list = []
for iter, (x, y) in enumerate(dataloader['test_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
testy = torch.Tensor(y).to(device)
if args.eRec:
testx = testx.transpose(0, 1)
testy = testy.transpose(0, 1)
testx = testx.transpose(-3, -1)
testy = testy.transpose(-3, -1)
with torch.no_grad():
if args.eRec:
preds = engine.model(testx, testy[:, :, 0:1, :, :],
scaler).transpose(1, 3)
else:
preds = engine.model(testx).transpose(1, 3)
#print(f'preds: {scaler.inverse_transform(torch.squeeze(preds.transpose(-3, -1))).shape}')
#print(f'testy: {torch.squeeze(testy[:, 0:1, :, :].transpose(-3, -1)).shape}')
if args.eRec:
loss_mse = criterion(
scaler.inverse_transform(torch.squeeze(preds.transpose(-3,
-1))),
torch.squeeze(testy[-1, :, 0:1, :, :].transpose(-3, -1)))
loss_mae = criterion2(
scaler.inverse_transform(torch.squeeze(preds.transpose(-3,
-1))),
torch.squeeze(testy[-1, :, 0:1, :, :].transpose(-3, -1)))
else:
loss_mse = criterion(
scaler.inverse_transform(torch.squeeze(preds.transpose(-3,
-1))),
torch.squeeze(testy[:, 0:1, :, :].transpose(-3, -1)))
loss_mae = criterion2(
scaler.inverse_transform(torch.squeeze(preds.transpose(-3,
-1))),
torch.squeeze(testy[:, 0:1, :, :].transpose(-3, -1)))
loss_mse_list.append(loss_mse)
loss_mae_list.append(loss_mae)
outputs.append(preds.squeeze())
loss_mse_list.pop(-1)
loss_mae_list.pop(-1)
loss_mse = torch.cat(loss_mse_list, 0)
loss_mae = torch.cat(loss_mae_list, 0)
#loss_mse = torch.squeeze(loss_mse).cpu()
#loss_mae = torch.squeeze(loss_mae).cpu()
loss_mse = loss_mse.cpu()
loss_mae = loss_mae.cpu()
print(f'loss_mae: {loss_mae.shape}')
print(f'loss_mse: {loss_mae.shape}')
res_folder = 'results/'
original_stdout = sys.stdout
with open(res_folder + f'loss_evaluation.txt', 'w') as filehandle:
sys.stdout = filehandle # Change the standard output to the file we created.
count_parameters(engine.model)
# loss_mae.shape --> (batch_size, seq_size, n_detect)
print(' 1. ***********')
print_loss('MSE', loss_mse)
print(' 2. ***********')
print_loss('MAE', loss_mae)
print(' 3. ***********')
print_loss_sensor('MAE', loss_mae)
print(' 5. ***********')
print_loss_seq('MAE', loss_mae)
print(' 6. ***********')
print_loss_sensor_seq('MAE', loss_mae)
sys.stdout = original_stdout # Reset the standard output to its original value
with open(res_folder + f'loss_evaluation.txt', 'r') as filehandle:
print(filehandle.read())
yhat = torch.cat(outputs, dim=0)
#print(f'yhat: {yhat.shape}')
yhat = yhat[:realy.size(0), ...]
#print(f'yhat2: {yhat.shape}')
print("Training finished")
#print("The valid loss on best model is", str(round(his_loss[bestid],4)))
amae = []
amape = []
armse = []
for i in range(args.seq_length):
pred = scaler.inverse_transform(yhat[:, :, i])
real = realy[:, :, i]
metrics = util.metric(pred, real)
log = 'Evaluate best model on test data for horizon {:d}, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(i + 1, metrics[0], metrics[1], metrics[2]))
amae.append(metrics[0])
amape.append(metrics[1])
armse.append(metrics[2])
log = 'On average over {:.4f} horizons, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(
log.format(args.seq_length, np.mean(amae), np.mean(amape),
np.mean(armse)))
torch.save(
engine.model.state_dict(), args.save + "_exp" + str(args.expid) +
"_best_" + str(round(np.min(his_loss), 2)) + ".pth")
for step, input in enumerate(data_eval):
pred, pred_prob, target = model(input)
y_pred[step, :] = pred
y_pred_prob[step, :] = pred_prob
y_gt[step, :] = target
llprint('\rEval--Epoch: %d, Step: %d/%d' %
(epoch, step, len(data_eval)))
end_time = time.time()
elapsed_time = (end_time - start_time) / 60
llprint(
'\n\tEpoch: %d, Loss: %.4f, One Epoch Time: %.2fm, Appro Left Time: %.2fm\n'
% (epoch, np.mean(loss_record), elapsed_time, elapsed_time *
(EPOCH - epoch - 1)))
js, auc, p_1, p_3, p_5, f1, auprc = metric(y_gt, y_pred, y_pred_prob)
llprint(
'\tJS: %.4f, AUC: %.4f, P1: %.4f, P3: %.4f, P5: %.4f, F1: %.4f, AUPRC: %.4F\n'
% (js, auc, p_1, p_3, p_5, f1, auprc))
torch.save(
model.state_dict(),
open(
os.path.join(
'saved', model_name, 'Epoch_%d_Loss_%.4f_P1_%.4f.model' %
(epoch, np.mean(loss_record), p_1)), 'wb'))
print('')
# test
torch.save(model.state_dict(),
open(os.path.join('saved', model_name, 'final.model'), 'wb'))
def main():
# set seed
torch.manual_seed(args.seed)
torch.cuda.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
np.random.seed(args.seed)
# load data
device = f'cuda:{args.device}' if torch.cuda.is_available() else 'cpu'
adj_mx = util.load_adj(adj_path, args.adjtype)
dataloader = util.load_dataset(outflow_path, args.batch_size,
args.batch_size, args.batch_size)
scaler = dataloader['scaler']
supports = [torch.tensor(i).to(device) for i in adj_mx]
if args.randomadj:
adjinit = None
else:
adjinit = supports[0]
if args.aptonly:
supports = None
engine = trainer(scaler, args.in_dim, args.seq_length, num_nodes,
args.nhid, args.dropout, args.learning_rate,
args.weight_decay, device, supports, args.gcn_bool,
args.addaptadj, adjinit)
logger.write("start training...")
his_loss = []
val_time = []
train_time = []
for i in range(1, args.epochs + 1):
# learning rate schedule
if i % 10 == 0:
lr = max(0.000002, args.learning_rate * (0.9**(i // 10)))
for g in engine.optimizer.param_groups:
g['lr'] = lr
# train
train_mae = []
train_rmse = []
train_mape = []
t1 = time.time()
dataloader['train_loader'].shuffle()
for iter, (x,
y) in enumerate(dataloader['train_loader'].get_iterator()):
trainx = torch.Tensor(x).to(device)
trainx = trainx.transpose(1, 3)
trainy = torch.Tensor(y).to(device)
trainy = trainy.transpose(1, 3)
# NOTE: B, T, V, F, F=2, but we noly need speed for label: y[:, 0, ...]
metrics = engine.train(trainx, trainy[:, 0, :, :])
train_mae.append(metrics[0])
train_rmse.append(metrics[1])
train_mape.append(metrics[2])
# log results of training set.
mtrain_mae = np.mean(train_mae)
mtrain_rmse = np.mean(train_rmse)
mtrain_mape = np.mean(train_mape) * 100
train_writer.add_scalar('train/mae', mtrain_mae, i)
train_writer.add_scalar('train/rmse', mtrain_rmse, i)
train_writer.add_scalar('train/mape', mtrain_mape, i)
# validation
with torch.no_grad():
valid_mae = []
valid_mape = []
valid_rmse = []
s1 = time.time()
for _, (x,
y) in enumerate(dataloader['val_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
testx = testx.transpose(1, 3)
testy = torch.Tensor(y).to(device)
testy = testy.transpose(1, 3)
metrics = engine.eval(testx, testy[:, 0, :, :])
valid_mae.append(metrics[0])
valid_rmse.append(metrics[1])
valid_mape.append(metrics[2])
# log results of validation set.
s2 = time.time()
val_time.append(s2 - s1)
mvalid_mae = np.mean(valid_mae)
mvalid_mape = np.mean(valid_mape) * 100
mvalid_rmse = np.mean(valid_rmse)
his_loss.append(mvalid_mae)
val_writer.add_scalar('val/mae', mvalid_mae, i)
val_writer.add_scalar('val/rmse', mvalid_rmse, i)
val_writer.add_scalar('val/mape', mvalid_mape, i)
t2 = time.time()
train_time.append(t2 - t1)
if i % args.print_every == 0:
logger.write(
f'Epoch: {i:03d}, MAE: {mtrain_mae:.2f}, RMSE: {mtrain_rmse:.2f}, MAPE: {mtrain_mape:.2f}, Valid MAE: {mvalid_mae:.2f}, RMSE: {mvalid_rmse:.2f}, MAPE: {mvalid_mape:.2f}'
)
torch.save(
engine.model.state_dict(), save_path + "_epoch_" + str(i) + "_" +
str(round(mvalid_mae, 2)) + ".pth")
logger.write("Average Training Time: {:.4f} secs/epoch".format(
np.mean(train_time)))
# logger.write("Average Inference Time: {:.4f} secs".format(np.mean(val_time)))
bestid = np.argmin(his_loss)
engine.model.load_state_dict(
torch.load(save_path + "_epoch_" + str(bestid + 1) + "_" +
str(round(his_loss[bestid], 2)) + ".pth"))
logger.write("Training finished")
logger.write(
f"The valid loss on best model is {str(round(his_loss[bestid],4))}")
# test
outputs = []
realy = torch.Tensor(dataloader['y_test']).to(device)
realy = realy.transpose(1, 3)[:, 0, :, :]
with torch.no_grad():
t1 = time.time()
for _, (x, y) in enumerate(dataloader['test_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
testx = testx.transpose(1, 3)
preds = engine.model(testx).transpose(1, 3)
outputs.append(preds.squeeze())
t2 = time.time()
logger.write(f'Inference time: {t2-t1:.4f}')
yhat = torch.cat(outputs, dim=0)
yhat = yhat[:realy.size(0), ...]
# calculate metrics and save predictions
preds = []
reals = []
logger.write('Step i, Test MAE, Test RMSE, Test MAPE')
for i in range(args.seq_length):
# prediction of step i
pred = scaler.inverse_transform(yhat[:, :, i])
real = realy[:, :, i]
metrics = util.metric(pred.cpu().detach().numpy(),
real.cpu().detach().numpy())
logger.write(
f'{metrics[0]:.2f}, {metrics[1]:.2f}, {metrics[2]*100:.2f}')
preds.append(pred.tolist())
reals.append(real.tolist())
reals = np.array(reals)
preds = np.array(preds)
np.save(f'test_{args.city}_{args.tinterval}.npy', np.array(reals))
np.save(f'test_{args.city}_{args.tinterval}.npy', np.array(preds))
torch.save(
engine.model.state_dict(), save_path + "_exp" + str(args.expid) +
"_best_" + str(round(his_loss[bestid], 2)) + ".pth")
def main():
device = torch.device(args.device)
_, _, adj_mx = util.load_adj(args.adjdata, args.adjtype)
supports = [torch.tensor(i).to(device) for i in adj_mx]
if args.randomadj:
adjinit = None
else:
adjinit = supports[0]
if args.aptonly:
supports = None
model = gwnet(device, args.num_nodes, args.dropout, supports=supports, gcn_bool=args.gcn_bool, addaptadj=args.addaptadj, aptinit=adjinit)
model.to(device)
model.load_state_dict(torch.load(args.checkpoint))
model.eval()
print('model load successfully')
dataloader = util.load_dataset(args.data, args.batch_size, args.batch_size, args.batch_size)
scaler = dataloader['scaler']
outputs = []
realy = torch.Tensor(dataloader['y_test']).to(device)
realy = realy.transpose(1,3)[:,0,:,:]
for iter, (x, y) in enumerate(dataloader['test_loader'].get_iterator()):
testx = torch.Tensor(x).to(device)
testx = testx.transpose(1,3)
with torch.no_grad():
preds = model(testx).transpose(1,3)
outputs.append(preds.squeeze())
yhat = torch.cat(outputs,dim=0)
yhat = yhat[:realy.size(0),...]
amae = []
amape = []
armse = []
for i in range(12):
pred = scaler.inverse_transform(yhat[:,:,i])
real = realy[:,:,i]
metrics = util.metric(pred,real)
log = 'Evaluate best model on test data for horizon {:d}, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(i+1, metrics[0], metrics[1], metrics[2]))
amae.append(metrics[0])
amape.append(metrics[1])
armse.append(metrics[2])
log = 'On average over 12 horizons, Test MAE: {:.4f}, Test MAPE: {:.4f}, Test RMSE: {:.4f}'
print(log.format(np.mean(amae),np.mean(amape),np.mean(armse)))
idx_list = list(range(1, 13)) + ['average']
amae.append(np.mean(amae))
amape.append(np.mean(amape))
armse.append(np.mean(armse))
df = pd.DataFrame(list(zip(idx_list, amae, amape, armse)), columns=['horizon', 'MAE', 'MAPE', 'RMSE'])
if args.savehorizon == 'True':
excel_dir = 'result.xlsx'
sheet_name= args.sheetname
if (os.path.isfile(excel_dir)): # append a new sheet
book = load_workbook(excel_dir)
with pd.ExcelWriter(excel_dir, engine='openpyxl') as writer:
writer.book = book
writer.sheets = dict((ws.title, ws) for ws in book.worksheets)
df.to_excel(writer, sheet_name=sheet_name, index=False)
writer.save()
writer.close()
else:
df.to_excel(excel_dir, sheet_name=sheet_name, index=False)
if args.plotheatmap == "True":
adp = F.softmax(F.relu(torch.mm(model.nodevec1, model.nodevec2)), dim=1)
device = torch.device('cpu')
adp.to(device)
adp = adp.cpu().detach().numpy()
adp = adp*(1/np.max(adp))
df = pd.DataFrame(adp)
sns.heatmap(df, cmap="RdYlBu")
plt.savefig("./emb"+ '.pdf')
# print(realy.shape) #torch.Size([6850, 207, 12]) (:, #node, window)
y12 = realy[:,99,11].cpu().detach().numpy()
yhat12 = scaler.inverse_transform(yhat[:,99,11]).cpu().detach().numpy()
y3 = realy[:,99,2].cpu().detach().numpy()
yhat3 = scaler.inverse_transform(yhat[:,99,2]).cpu().detach().numpy()
df2 = pd.DataFrame({'real12':y12,'pred12':yhat12, 'real3': y3, 'pred3':yhat3})
df2.to_csv('./wave.csv',index=False)
model_type = 'XGBoost'
if train_on_subset_data:
r2, _ = train_on_different_classes(subset_type, equal=False)
r2.insert(0, model_type)
csv_writer.writerow(r2)
if train_on_whole_data:
x_train, x_test, y_train, y_test = transform_data(
x_data=train_data, y_data=label, test_size=0.1, random_state=4)
kappa_model = KappaModel(x_train, x_test, y_train, y_test)
kappa_model.train_model(model, epochs=epochs)
predict_train = kappa_model.predict(model, 'train')
predict_test = kappa_model.predict(model, 'test')
r2_train, mae_log_train, rmse_train = metric(
y_train, predict_train)
r2_test, mae_log_test, rmse_test = metric(y_cal=y_test,
y_pred=predict_test)
MAEs_train = mae(np.exp(y_train), np.exp(predict_train))
MAEs_test = mae(np.exp(y_test), np.exp(predict_test))
print(mae_log_test, r2_test)
metric_list = [
MAEs_train, MAEs_test, r2_train, r2_test, mae_log_train,
mae_log_test, rmse_train, rmse_test
]
metric_matrix.append(metric_list)
if train_on_whole_data:
metric_matrix.insert(0, [
'MAEs of train data', 'MAEs of test data', 'R2 of train data',
