# tf.add_to_collection(name='graph_kernel', value=tf.cast(tf.constant(Lk), tf.float32))
#
# # Data Preprocessing
# data_file = f'PeMSD7_V_{n}.csv'
# n_train, n_val, n_test = 34, 5, 5
# PeMS = data_gen(pjoin('./dataset', data_file), (n_train, n_val, n_test), n, n_his + n_pred)
# print(f'>> Loading dataset with Mean: {PeMS.mean:.2f}, STD: {PeMS.std:.2f}')
# Load wighted adjacency matrix W
if args.graph == 'default':
W = weight_matrix(pjoin('./dataset', f'W_228.csv'))
else:
# load customized graph weight matrix
W = weight_matrix(pjoin('./dataset', args.graph))
# Calculate graph kernel
L = scaled_laplacian(W)
# Alternative approximation method: 1st approx - first_approx(W, n).
Lk = cheb_poly_approx(L, Ks, n)
tf.add_to_collection(name='graph_kernel', value=tf.cast(tf.constant(Lk), tf.float32))
# Data Preprocessing
data_file = f'V_228.csv'
n_train, n_val, n_test = 34, 5, 5
PeMS = data_gen(pjoin('./dataset', data_file), (n_train, n_val, n_test), n, n_his + n_pred)
print(f'>> Loading dataset with Mean: {PeMS.mean:.2f}, STD: {PeMS.std:.2f}')
if __name__ == '__main__':
model_train(PeMS, blocks, args)
model_test(PeMS, PeMS.get_len('test'), n_his, n_pred, args.inf_mode)
def main(args):
"""main"""
# PeMS = data_gen_mydata(args.input_file, args.label_file, args.n_route, args.n_his,
# args.n_pred, (args.n_val, args.n_test))
PeMS = data_gen_custom(args.input_file, args.label_file, args.city_file,
args.n_route, args.n_his, args.n_pred,
(args.n_val, args.n_test))
log.info(PeMS.get_stats())
log.info(PeMS.get_len('train'))
gf = GraphFactory(args)
place = fluid.CUDAPlace(0) if args.use_cuda else fluid.CPUPlace()
train_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(train_program, startup_program):
gw = pgl.graph_wrapper.GraphWrapper("gw",
place,
node_feat=[('norm', [None, 1],
"float32")],
edge_feat=[('weights', [None, 1],
"float32")])
model = STGCNModel(args, gw)
train_loss, y_pred = model.forward()
infer_program = train_program.clone(for_test=True)
with fluid.program_guard(train_program, startup_program):
epoch_step = int(PeMS.get_len('train') / args.batch_size) + 1
lr = fl.exponential_decay(learning_rate=args.lr,
decay_steps=5 * epoch_step,
decay_rate=0.7,
staircase=True)
if args.opt == 'RMSProp':
train_op = fluid.optimizer.RMSPropOptimizer(lr).minimize(
train_loss)
elif args.opt == 'ADAM':
train_op = fluid.optimizer.Adam(lr).minimize(train_loss)
exe = fluid.Executor(place)
exe.run(startup_program)
if args.inf_mode == 'sep':
# for inference mode 'sep', the type of step index is int.
step_idx = args.n_pred - 1
tmp_idx = [step_idx]
min_val = min_va_val = np.array([4e1, 1e5, 1e5])
elif args.inf_mode == 'merge':
# for inference mode 'merge', the type of step index is np.ndarray.
step_idx = tmp_idx = np.arange(3, args.n_pred + 1, 3) - 1
min_val = min_va_val = np.array([4e1, 1e5, 1e5]) * len(step_idx)
else:
raise ValueError(f'ERROR: test mode "{inf_mode}" is not defined.')
step = 0
for epoch in range(1, args.epochs + 1):
for idx, x_batch in enumerate(
gen_batch(PeMS.get_data('train'),
args.batch_size,
dynamic_batch=True,
shuffle=True)):
x = np.array(x_batch[:, 0:args.n_his, :, :], dtype=np.float32)
graph = gf.build_graph(x)
feed = gw.to_feed(graph)
feed['input'] = np.array(x_batch[:, 0:args.n_his + 1, :, :],
dtype=np.float32)
b_loss, b_lr = exe.run(train_program,
feed=feed,
fetch_list=[train_loss, lr])
if idx % 5 == 0:
log.info("epoch %d | step %d | lr %.6f | loss %.6f" %
(epoch, idx, b_lr[0], b_loss[0]))
min_va_val, min_val = \
model_inference(exe, gw, gf, infer_program, y_pred, PeMS, args, \
step_idx, min_va_val, min_val)
for ix in tmp_idx:
va, te = min_va_val[ix - 2:ix + 1], min_val[ix - 2:ix + 1]
print(f'Time Step {ix + 1}: '
f'MAPE {va[0]:7.3%}, {te[0]:7.3%}; '
f'MAE {va[1]:4.3f}, {te[1]:4.3f}; '
f'RMSE {va[2]:6.3f}, {te[2]:6.3f}.')
if epoch % 5 == 0:
model_test(exe, gw, gf, infer_program, y_pred, PeMS, args)
print(f'>> Loading dataset with Mean: {data.mean:.2f}, STD: {data.std:.2f}')
n, n_his, n_pred = args.n_route, args.n_his, args.n_pred
Ks, Kt = args.ks, args.kt
# blocks: settings of channel size in st_conv_blocks / bottleneck design
#blocks = [[2, 32, 64], [64, 32, 128]]
blocks = [[2, 32, 64]]
# Load wighted adjacency matrix W
if args.trained_adj_mx:
L = tf.get_variable('weight_matrix', shape=(n, n), dtype=tf.float32)
Lk = cheb_poly_approx_tf(L, Ks, n)
#W = weight_matrix(pjoin('./dataset', f'PeMSD7_W_{n}.csv'))
tf.add_to_collection(name='graph_kernel', value=Lk)
else:
# load customized graph weight matrix
#W = weight_matrix(pjoin('./dataset', args.graph))
w = np.load(data_folder + 'w.npy')
#w = np.array(w, dtype=np.float32)
W = get_rescaled_W(w, delta=args.delta, epsilon=args.epsilon)
# Calculate graph kernel
L = scaled_laplacian(W)
# Alternative approximation method: 1st approx - first_approx(W, n).
Lk = cheb_poly_approx(L, Ks, n)
tf.add_to_collection(name='graph_kernel',
value=tf.cast(tf.constant(Lk), tf.float32))
if __name__ == '__main__':
model_train(data, blocks, args)
model_test(data, data.get_len('test'), n_his, n_pred, args.inf_mode)
data_file = 'traffic_data.csv'
n_train, n_val, n_test = 3, 3, 3 # 61 in total
step_train, step_val, step_test = 8, 8, 8
PeMS = data_gen(pjoin('./qtraffic', data_file), (n_train, n_val, n_test),
(step_train, step_val, step_test),
n,
n_his + n_pred,
day_slot=96)
print(f'>> Loading dataset with Mean: {PeMS.mean:.2f}, STD: {PeMS.std:.2f}')
train_shape = PeMS.get_data('train').shape
val_shape = PeMS.get_data('val').shape
test_shape = PeMS.get_data('test').shape
print(f'datashape as: train:{train_shape},valid:{val_shape},test:{test_shape}')
subset = read_pickle('qtraffic/road_subset.pk')
W = read_pickle('qtraffic/W.pk')
print(f'W.shape={W.shape}')
# Calculate graph kernel
L = scaled_laplacian(W)
# Alternative approximation method: 1st approx - first_approx(W, n).
Lk = cheb_poly_approx(L, Ks, n)
tf.add_to_collection(name='graph_kernel',
value=tf.cast(tf.constant(Lk), tf.float32))
if __name__ == '__main__':
model_train(PeMS, blocks, args, load=False)
model_test(PeMS, 100, n_his, n_pred, args.inf_mode)
# os.system("shutdown -s -t 0");
pass
# Load wighted adjacency matrix W
if args.graph == 'default':
W = weight_matrix(pjoin('./dataset', f'w.csv'))
else:
# load customized graph weight matrix
W = weight_matrix(pjoin('./dataset', args.graph))
# Calculate graph kernel
L = scaled_laplacian(W)
# Alternative approximation method: 1st approx - first_approx(W, n).
Lk = cheb_poly_approx(L, Ks, n)
tf.add_to_collection(name='graph_kernel',
value=tf.cast(tf.constant(Lk), tf.float32))
# Data Preprocessing
data_file = f'v.csv'
n_train, n_val, n_test = 34, 5, 5
TaiAn = data_gen(pjoin('./dataset', data_file), (n_train, n_val, n_test), n,
n_his + n_pred)
print(f'>> Loading dataset with Mean: {TaiAn.mean:.2f}, STD: {TaiAn.std:.2f}')
if __name__ == '__main__':
# model_train(TaiAn, blocks, args,path='./output60min/')
model_test(TaiAn,
TaiAn.get_len('test'),
n_his,
n_pred,
args.inf_mode,
path='./output60min/')
raw_data_path = pjoin(
data_path, 'train_val'
) #the folder contain train and validation as the data used in the paper
indicies = utcPlus3
if args.city == 'Berlin':
indicies = utcPlus2
traffic4cast_data = data_gen_traffic4cast(raw_data_path,
process_data_dir,
node_pos,
args.seq_len,
args.horizon,
data_start=0,
val_indices=indicies,
train_ratios=0.8,
val_ratios=0.1)
# Data Preprocessing
# data_file = f'PeMSD7_V_{n}.csv'
# n_train, n_val, n_test = 34, 5, 5
# PeMS = data_gen(pjoin('./dataset', data_file), (n_train, n_val, n_test), n, n_his + n_pred)
print(
f'>> Loading dataset with Mean: {traffic4cast_data.mean:.2f}, STD: {traffic4cast_data.std:.2f}'
)
if __name__ == '__main__':
model_train(traffic4cast_data, blocks, args, output_dim=3)
model_test(traffic4cast_data, traffic4cast_data.get_len('test'),
args.seq_len, args.horizon, args.inf_mode)
