def main():
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
parser = argparse.ArgumentParser(
description="PyTorch Query Localization in Videos Training")
parser.add_argument(
"--config-file",
default="experiments/charades_sta_train.yaml",
# default="experiments/anet_cap_train.yaml",
# default="experiments/tacos_train.yaml",
metavar="FILE",
help="path to config file",
type=str,
)
args = parser.parse_args()
experiment_name = args.config_file.split("/")[-1]
log_directory = args.config_file.replace(experiment_name, "logs/")
vis_directory = args.config_file.replace(experiment_name, "visualization/")
experiment_name = experiment_name.replace(".yaml", "")
cfg.merge_from_list([
'EXPERIMENT_NAME', experiment_name, 'LOG_DIRECTORY', log_directory,
"VISUALIZATION_DIRECTORY", vis_directory
])
cfg.merge_from_file(args.config_file)
output_dir = "./{}".format(cfg.LOG_DIRECTORY)
if output_dir:
mkdir(output_dir)
mkdir("./checkpoints/{}".format(cfg.EXPERIMENT_NAME))
logger = setup_logger("mlnlp", output_dir, cfg.EXPERIMENT_NAME + ".txt", 0)
logger.info("Starting moment localization with dynamic filters")
logger.info(cfg.EXPERIMENT_NAME)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
# torch.backends.cudnn.enabled = False
if cfg.ENGINE_STAGE == "TRAINER":
print('#######')
print(cfg.DYNAMIC_FILTER.LSTM_VIDEO.DROPOUT)
trainer(cfg)
elif cfg.ENGINE_STAGE == "TESTER":
tester(cfg)
def main():
parser = argparse.ArgumentParser(description="PyTorch Object Detection Training")
parser.add_argument(
"--config-file",
default="",
metavar="FILE",
help="path to config file",
type=str,)
args = parser.parse_args()
experiment_name = args.config_file.split("/")[-1]
log_directory = args.config_file.replace(experiment_name,"logs/")
vis_directory = args.config_file.replace(experiment_name,"visualization/")
experiment_name = experiment_name.replace(".yaml","")
cfg.merge_from_list(['EXPERIMENT_NAME', experiment_name, 'LOG_DIRECTORY', log_directory, "VISUALIZATION_DIRECTORY", vis_directory])
cfg.merge_from_file(args.config_file)
output_dir = "./{}".format(cfg.LOG_DIRECTORY)
if output_dir:
mkdir(output_dir)
mkdir("./checkpoints/{}".format(cfg.EXPERIMENT_NAME))
logger = setup_logger("mlnlp", output_dir, cfg.EXPERIMENT_NAME + ".txt", 0)
logger.info("Starting moment localization with dynamic filters")
logger.info(cfg.EXPERIMENT_NAME)
# reproductibility
np.random.seed(0)
torch.manual_seed(0)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
if cfg.ENGINE_STAGE == "TRAINER":
trainer(cfg)
elif cfg.ENGINE_STAGE == "TESTER":
tester(cfg)
def main():
#load data
device = torch.device(args.device)
# sensor_ids, sensor_id_to_ind, adj_mx = util.load_adj(args.adjdata,args.adjtype)
# supports = [torch.tensor(i).to(device) for i in adj_mx]
adjinit = None
supports = None
engine = trainer(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)
engine.model.load_state_dict(torch.load(args.load, map_location={'cuda:1': 'cuda:0'}))
# engine.model.load_state_dict(torch.load(args.load))
print("start testing...", flush=True)
val_time = []
data = dataLoader( bs = args.batch_size, sl = args.seq_length, fd_number =args.fd_number)
#test
test_loss = []
test_asf = []
test_rmse = []
s1 = time.time()
for iter in range(data.test_batches):
testx, testy = data.testLoader.nextBatch()
testx = testx[:, :, :, np.newaxis]
testx = torch.Tensor(testx).to(device)
testx = testx.permute((0, 3, 2, 1))
testy = torch.Tensor(testy).to(device)
metrics = engine.eval(testx, testy)
test_loss.append(metrics[0])
test_rmse.append(metrics[1])
test_asf.append(metrics[2])
s2 = time.time()
val_time.append(s2-s1)
test_loss = np.mean(test_loss)
test_rmse = np.mean(test_rmse)
test_asf = np.mean(test_asf)
log = 'Test Loss: {:.4f},Test RMSE: {:.4f}, Test_asf:{:.4f}, inference Time: {:.4f}/epoch'
print(log.format(test_loss, test_rmse, test_asf, (s2 - s1)),flush=True)
def build_model(args):
device = torch.device(args.device)
adj_mx = load_adj(args.adjdata, args.adjtype)
dataloader = 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)
return engine, scaler, dataloader, adj_mx
def test_sample(sample_num):
device = torch.device(args.device)
# sensor_ids, sensor_id_to_ind, adj_mx = util.load_adj(args.adjdata,args.adjtype)
# supports = [torch.tensor(i).to(device) for i in adj_mx]
print(args)
adjinit = None
supports = None
engine = trainer(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)
engine.model.load_state_dict(torch.load(args.load,map_location={'cuda:1':'cuda:0'}))
data = dataLoader( bs = args.batch_size, sl = args.seq_length, fd_number =args.fd_number)
test_feature, test_label = data.get_one_piece(sample_num)
test_feature_b = np.reshape(test_feature, [len(test_feature), args.seq_length, 18])
test_feature_b = test_feature_b[:, :, :, np.newaxis]
test_feature_b = torch.Tensor(test_feature_b).to(device)
test_feature_b = test_feature_b.permute((0, 3, 2, 1))
result = engine.eval2(test_feature_b)
# bc = len(test_feature)//args.batch_size
# result = []
# for i in range(bc):
# test_feature_b = np.reshape(test_feature[bc*args.batch_size, (bc+1)*args.batch_size], [args.batch_size, args.seq_length, -1])
# result = result + engine.model.eval2(test_feature_b)
p = 1
leng = len(result)
plt.plot(range(leng), result, marker='|', color='coral', linewidth=1.0, linestyle='--', label='Prediction')
plt.plot(range(leng), test_label, linestyle='-', label='Label ')
plt.xlabel("Time(Cycle)")
plt.ylabel("RUL(Cycle)")
plt.title(r"RUL prediction sample")
plt.legend()
# plt.savefig(path)
plt.show()
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():
if not os.path.exists(args.save):
os.makedirs(args.save)
#load data
device = torch.device(args.device)
# sensor_ids, sensor_id_to_ind, adj_mx = util.load_adj(args.adjdata,args.adjtype)
# supports = [torch.tensor(i).to(device) for i in adj_mx]
print(args)
adjinit = None
supports = None
engine = trainer(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)
train_his_loss = []
his_loss = []
val_time = []
train_time = []
data = dataLoader(bs=args.batch_size,
sl=args.seq_length,
fd_number=args.fd_number)
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_asf = []
train_rmse = []
t1 = time.time()
for iter in range(data.train_batches):
trainx, trainy = data.trainLoader.nextBatch()
trainx = trainx[:, :, :, np.newaxis]
trainx = torch.Tensor(trainx).to(device)
trainx = trainx.permute((0, 3, 2, 1))
trainy = torch.Tensor(trainy).to(device)
metrics = engine.train(trainx, trainy)
# mc = engine.eval(trainx,trainy)
train_loss.append(metrics[0])
train_asf.append(metrics[2])
train_rmse.append(metrics[1])
if iter % args.print_every == 0:
log = 'Iter: {:03d}, Train Loss: {:.4f},Train RMSE: {:.4f},Train asf: {:.4f}'
print(log.format(iter, train_loss[-1], train_rmse[-1],
train_asf[-1]),
flush=True)
t2 = time.time()
train_time.append(t2 - t1)
#validation
valid_loss = []
valid_asf = []
valid_rmse = []
s1 = time.time()
for iter in range(data.test_batches):
testx, testy = data.testLoader.nextBatch()
testx = testx[:, :, :, np.newaxis]
testx = torch.Tensor(testx).to(device)
testx = testx.permute((0, 3, 2, 1))
testy = torch.Tensor(testy).to(device)
metrics = engine.eval(testx, testy)
valid_loss.append(metrics[0])
valid_rmse.append(metrics[1])
valid_asf.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_rmse = np.mean(train_rmse)
mtrain_asf = np.mean(train_asf)
mvalid_loss = np.mean(valid_loss)
mvalid_rmse = np.mean(valid_rmse)
mvalid_asf = np.mean(valid_asf)
his_loss.append(mvalid_loss)
train_his_loss.append(train_loss)
log = 'Epoch: {:03d}, Train Loss: {:.4f},Train RMSE: {:.4f}, Train_asf:{:.4f}, Valid Loss: {:.4f},Valid RMSE: {:.4f}, Valid_asf:{:.4f}, Training Time: {:.4f}/epoch'
print(log.format(i, mtrain_loss, mtrain_rmse, mtrain_asf, mvalid_loss,
mvalid_rmse, mvalid_asf, (t2 - t1)),
flush=True)
torch.save(
engine.model.state_dict(), args.save + "epoch_" + str(i) + "_" +
str(round(mvalid_loss, 2)) + ".pth")
for k in range(5):
test_sample(k + 2, engine, data, device,
args.save + "epoch_" + str(i) + '_' + str(k))
print("Average Training Time: {:.4f} secs/epoch".format(
np.mean(train_time)))
print("Average Inference Time: {:.4f} secs".format(np.mean(val_time)))
np.save(args.save + "valiloss.npy", his_loss)
np.save(args.save + "trainloss.npy", train_his_loss)
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")
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():
# 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")
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(model_name=None,
syn_file='syn_diffG.pkl'
): # directly loading trained model/ generated syn data
#set seed
#torch.manual_seed(args.seed)
#np.random.seed(args.seed)
#load data
same_G = False
device = torch.device(args.device)
if args.data == 'syn':
if os.path.isfile(syn_file):
with open(syn_file, 'rb') as handle:
pkl_data = pickle.load(handle)
nTrain, nValid, nTest, num_timestep = pkl_data['nTrain'], pkl_data['nValid'],\
pkl_data['nTest'], pkl_data['num_timestep']
dataloader, adj_mx, F_t, G = pkl_data['dataloader'], pkl_data['adj_mx'],\
pkl_data['F_t'], pkl_data['G']
print('synthetic data loaded')
else:
nTrain = 80 # Number of training samples
nValid = int(0.25 * nTrain) # Number of validation samples
nTest = int(0.05 * nTrain) # Number of testing samples
num_timestep = 1000 # 1000
dataloader, adj_mx, F_t, G = util.load_dataset_syn(args.adjtype,
args.num_nodes,
nTrain,
nValid,
nTest,
num_timestep,
args.seq_length,
args.batch_size,
args.batch_size,
args.batch_size,
same_G=same_G)
# pkl_data = {'nTrain': nTrain, 'nValid': nValid, 'nTest': nTest,
# 'num_timestep': num_timestep, 'dataloader': dataloader,
# 'adj_mx': adj_mx, 'F_t': F_t, 'G':G}
# with open(syn_file, 'wb') as handle:
# pickle.dump(pkl_data, handle, protocol=pickle.HIGHEST_PROTOCOL)
elif args.data == 'CRASH':
util.load_dataset_CRASH(args.adjtype, args.batch_size, args.batch_size,
args.batch_size)
else:
sensor_ids, sensor_id_to_ind, adj_mx = util.load_adj(
args.adjdata, args.adjtype)
dataloader = util.load_dataset_metr(args.data, args.batch_size,
args.batch_size, args.batch_size)
if args.data == 'syn' and not same_G: # different graph structure for each sample
assert len(adj_mx) == nTrain + nValid + nTest
# separate adj matrices into train-val-test samples
adj_train = [[], []]
for a in adj_mx[:nTrain]:
adj_train[0].append(a[0])
adj_train[1].append(a[1])
adj_train = [np.stack(np.asarray(i)) for i in adj_train]
adj_val = [[], []]
for a in adj_mx[nTrain:-nTest]:
adj_val[0].append(a[0])
adj_val[1].append(a[1])
adj_val = [np.stack(np.asarray(i)) for i in adj_val]
adj_test = [[], []]
for a in adj_mx[-nTest:]:
adj_test[0].append(a[0])
adj_test[1].append(a[1])
adj_test = [np.stack(np.asarray(i)) for i in adj_test]
scaler = dataloader['scaler']
print(args)
supports = {}
supports['train'] = [torch.tensor(i).to(device) for i in adj_train]
supports['val'] = [torch.tensor(i).to(device) for i in adj_val]
supports['test'] = [torch.tensor(i).to(device) for i in adj_test]
adjinit = {}
if args.randomadj:
adjinit['train'] = adjinit['val'] = adjinit['test'] = None
else:
adjinit['train'] = supports['train'][0]
adjinit['val'] = supports['val'][0]
adjinit['test'] = supports['test'][0]
if args.aptonly:
supports['train'] = supports['val'] = supports['test'] = 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.blocks, args.layers)
if model_name is None:
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()
engine.set_state('train')
for iter, (x, y, adj_idx) in enumerate(
dataloader['train_loader'].get_iterator()):
trainx = torch.Tensor(x).to(
device) # torch.Size([64, 15, 80, 2])
trainx = trainx.transpose(1,
3) # torch.Size([64, 2, 80, 15])
trainy = torch.Tensor(y).to(device)
trainy = trainy.transpose(1, 3)
metrics = engine.train_syn(trainx, trainy, F_t, G['train'],
adj_idx)
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()
engine.set_state('val')
for iter, (x, y, adj_idx) 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)
# [64, 2, 80, 15]
metrics = engine.eval_syn(testx, testy, F_t, G['val'],
adj_idx)
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)))
else:
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.blocks, args.layers)
if model_name is None:
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) # torch.Size([64, 12, 207, 2])
trainx = trainx.transpose(
1, 3) # torch.Size([64, 2, 207, 12])
trainy = torch.Tensor(y).to(device)
trainy = trainy.transpose(1, 3)
if args.data == 'syn':
metrics = engine.train_syn(trainx, trainy, F_t, G)
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)
testx = testx.transpose(1, 3)
testy = torch.Tensor(y).to(device)
testy = testy.transpose(1, 3)
if args.data == 'syn':
metrics = engine.eval_syn(testx, testy, F_t, G)
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 ################################
if model_name is None:
bestid = np.argmin(his_loss)
print(bestid)
print("Training finished")
print("The valid loss on best model is",
str(round(his_loss[bestid], 4)))
engine.model.load_state_dict(
torch.load(args.save + "_epoch_" + str(bestid + 1) + "_" +
str(round(his_loss[bestid], 2)) + ".pth"))
else:
engine.model.load_state_dict(torch.load(model_name))
amae = []
amape = []
armse = []
if args.data == 'syn':
if same_G:
for iter, (x, y) in enumerate(
dataloader['test_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)
# [64, 2, 80, 15]
metrics = engine.eval_syn(testx, testy, F_t, G)
amae.append(metrics[0])
amape.append(metrics[1])
armse.append(metrics[2])
else:
engine.set_state('test')
reals = []
pred_Fs = []
pred_Es = []
for iter, (x, y, adj_idx) in enumerate(
dataloader['test_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)
# [64, 2, 80, 15]
metrics = engine.eval_syn(testx, testy, F_t, G['val'], adj_idx)
amae.append(metrics[0])
amape.append(metrics[1])
armse.append(metrics[2])
reals.append(testy)
pred_Fs.append(metrics[3])
pred_Es.append(metrics[4])
reals = torch.stack(reals).cpu().numpy()
reals = reals.reshape(-1, *reals.shape[2:])
pred_Fs = torch.stack(pred_Fs).cpu().numpy()
pred_Fs = pred_Fs.reshape(-1, *pred_Fs.shape[2:]).squeeze()
pred_Es = torch.stack(pred_Es).cpu().numpy()
pred_Es = pred_Es.reshape(-1, *pred_Es.shape[2:]).squeeze()
# reals shape: (1984, 2, 80, 15); pred_F/Es shape:(1984, 80, 15)
# reverse slideing window --> results: (num_nodes, total_timesteps)
ret = util.reverse_sliding_window([
reals[:, 0, :, :].squeeze(), reals[:, 1, :, :].squeeze(),
pred_Fs, pred_Es
])
viz_node_idx = 0
plt.figure()
plt.plot(ret[0][viz_node_idx, :], label='real F')
plt.plot(ret[1][viz_node_idx, :], label='real E')
plt.plot(ret[2][viz_node_idx, :], label='pred F')
plt.plot(ret[3][viz_node_idx, :], label='pred E')
plt.legend()
plt.show()
if model_name is None:
log = 'On average over seq_length 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")
else:
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), ...]
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 seq_length 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")
