def task(share_queue, locker, data, parameters):
print('Child process %s with pid %s' % (parameters[0], os.getpid()))
val_collector = {}
test_collector = {}
for i in data:
print('Child process %s' % (parameters[0]),
args['Dataset'], args['City'], 'Station', i, 'total', data_loader.station_number)
try:
model_obj = ARIMA(time_sequence=data_loader.train_closeness[:, i, -1, 0],
order=[args['ar'], args['d'], args['ma']],
seasonal_order=[args['sar'], args['sd'], args['sma'], args['sp']])
test_prediction = model_obj.predict(time_sequences=data_loader.test_closeness[:, i, :, 0], forecast_step=1)
del model_obj
except Exception as e:
print('Converge failed with error', e)
print('Using last as prediction')
test_prediction = data_loader.test_closeness[:, i, -1:, :]
test_collector[i] = test_prediction
print('Station', i, metric.rmse(test_prediction, data_loader.test_y[:, i:i + 1], threshold=0))
locker.acquire()
share_queue.put([val_collector, test_collector])
locker.release()
def show_prediction(prediction, target, station_index, start=0, end=-1):
import matplotlib.pyplot as plt
# fig, axs = plt.subplots(1, 2, figsize=(9, 3))
# axs[0].plot(prediction[start:end, station_index])
# axs[1].plot(target[start:end, station_index])
plt.plot(prediction[start:end, station_index], 'b')
plt.plot(target[start:end, station_index], 'r')
print(metric.rmse(prediction[start:end, station_index], target[start:end, station_index]))
print(prediction[start:end, station_index].max(), target[start:end, station_index].max())
print(prediction[start:end, station_index].min(), target[start:end, station_index].min())
plt.show()
train = np.concatenate(train, axis=-1)
test_x = np.concatenate(test_x, axis=-1)
# val has the same length as test
train_x, val_x = train[:-len(test_x)], train[-len(test_x):]
train_y, val_y = data_loader.train_y[:-len(test_x),
i], data_loader.train_y[-len(test_x):,
i]
model.fit(train_x, train_y, num_boost_round=int(params['num_boost_round']))
test_p = model.predict(test_x).reshape([-1, 1, 1])
val_p = model.predict(val_x).reshape([-1, 1, 1])
test_prediction.append(test_p)
val_prediction.append(val_p)
test_prediction = np.concatenate(test_prediction, axis=-2)
val_prediction = np.concatenate(val_prediction, axis=-2)
val_rmse = metric.rmse(val_prediction,
data_loader.train_y[-len(data_loader.test_y):],
threshold=0)
test_rmse = metric.rmse(test_prediction, data_loader.test_y, threshold=0)
# nni.report_final_result({
# 'default': val_rmse,
# 'test-rmse': test_rmse,
# })
external_feature=data_loader.test_ef,
output_names=('prediction', ),
sequence_length=data_loader.test_sequence_len,
cache_volume=int(args['batch_size']),
)
test_prediction = prediction['prediction']
if de_normalizer:
test_prediction = de_normalizer(test_prediction)
data_loader.test_y = de_normalizer(data_loader.test_y)
val_prediction = de_normalizer(val_prediction)
val_y = de_normalizer(val_y)
test_rmse = metric.rmse(prediction=test_prediction,
target=data_loader.test_y,
threshold=0)
val_rmse = metric.rmse(prediction=val_prediction, target=val_y, threshold=0)
# Evaluate loss during training
val_loss = STMeta_obj.load_event_scalar('val_loss')
# best_val_loss = min([e[-1] for e in val_loss])
# if de_normalizer:
# best_val_loss = de_normalizer(best_val_loss)
# print('Best val result', best_val_loss)
print('Val result', val_rmse)
print('Test result', test_rmse)
time_consumption = [
val_loss[e][0] - val_loss[e - 1][0] for e in range(1, len(val_loss))
]
code_version='DCRNN-QuickStart',
model_dir='model_dir',
gpu_device='0')
# Build tf-graph
DCRNN_Obj.build()
print('Number of trainable parameters', DCRNN_Obj.trainable_vars)
# Training
DCRNN_Obj.fit(inputs=np.concatenate((data_loader.train_trend.transpose([0, 2, 1, 3]),
data_loader.train_period.transpose([0, 2, 1, 3]),
data_loader.train_closeness.transpose([0, 2, 1, 3])), axis=1),
diffusion_matrix=diffusion_matrix,
target=data_loader.train_y.reshape([-1, 1, data_loader.station_number, 1]),
batch_size=batch_size,
sequence_length=data_loader.train_sequence_len)
# Predict
prediction = DCRNN_Obj.predict(inputs=np.concatenate((data_loader.test_trend.transpose([0, 2, 1, 3]),
data_loader.test_period.transpose([0, 2, 1, 3]),
data_loader.test_closeness.transpose([0, 2, 1, 3])), axis=1),
diffusion_matrix=diffusion_matrix,
target=data_loader.test_y.reshape([-1, 1, data_loader.station_number, 1]),
sequence_length=data_loader.test_sequence_len,
output_names=['prediction'])
# Evaluate
print('Test result', metric.rmse(prediction=data_loader.normalizer.min_max_denormal(prediction['prediction']),
target=data_loader.normalizer.min_max_denormal(data_loader.test_y.transpose([0, 2, 1])),
threshold=0))
X_Train.append(train_closeness[:, i, :, 0])
X_Val.append(val_closeness[:, i, :, 0])
X_Test.append(data_loader.test_closeness[:, i, :, 0])
if period_len > 0:
X_Train.append(train_period[:, i, :, 0])
X_Val.append(val_period[:, i, :, 0])
X_Test.append(data_loader.test_period[:, i, :, 0])
if trend_len > 0:
X_Train.append(train_trend[:, i, :, 0])
X_Val.append(val_trend[:, i, :, 0])
X_Test.append(data_loader.test_trend[:, i, :, 0])
X_Train = np.concatenate(X_Train, axis=-1)
X_Val = np.concatenate(X_Val, axis=-1)
X_Test = np.concatenate(X_Test, axis=-1)
model.fit(X_Train, train_y[:, i, 0])
p_val = model.predict(X_Val)
p_test = model.predict(X_Test)
prediction_test.append(p_test.reshape([-1, 1, 1]))
prediction_val.append(p_val.reshape([-1, 1, 1]))
prediction_test = np.concatenate(prediction_test, axis=-2)
prediction_val = np.concatenate(prediction_val, axis=-2)
print('Val RMSE', metric.rmse(prediction_val, val_y, threshold=0))
print('Test RMSE', metric.rmse(prediction_test,
data_loader.test_y,
threshold=0))
test_collector[i] = test_prediction
print('Station', i, metric.rmse(test_prediction, data_loader.test_y[:, i:i + 1], threshold=0))
locker.acquire()
share_queue.put([val_collector, test_collector])
locker.release()
def reduce_fn(a, b):
a[0].update(b[0])
a[1].update(b[1])
return a
if __name__ == '__main__':
n_job = 8
result = multiple_process(distribute_list=range(data_loader.station_number),
partition_func=lambda data, i, n_job:
[data[e] for e in range(len(data)) if e % n_job == i],
task_func=task, n_jobs=n_job, reduce_func=reduce_fn, parameters=[])
test_rmse_collector = [e[1] for e in sorted(result[1].items(), key=lambda x: x[0])]
test_rmse_collector = np.concatenate(test_rmse_collector, axis=-2)
test_rmse = metric.rmse(test_rmse_collector, data_loader.test_y, threshold=0)
print(args['Dataset'], args['City'], 'test_rmse', test_rmse)
print('*************************************************************')
print('Station', i)
model = GradientBoostingRegressor(n_estimators=100, max_depth=3)
X_Train = []
X_Test = []
if closeness_len > 0:
X_Train.append(data_loader.train_closeness[:, i, :, 0])
X_Test.append(data_loader.test_closeness[:, i, :, 0])
if period_len > 0:
X_Train.append(data_loader.train_period[:, i, :, 0])
X_Test.append(data_loader.test_period[:, i, :, 0])
if trend_len > 0:
X_Train.append(data_loader.train_trend[:, i, :, 0])
X_Test.append(data_loader.test_trend[:, i, :, 0])
X_Train = np.concatenate(X_Train, axis=-1)
X_Test = np.concatenate(X_Test, axis=-1)
model.fit(X_Train, data_loader.train_y[:, i, 0])
p = model.predict(X_Test)
prediction.append(p.reshape([-1, 1, 1]))
prediction = np.concatenate(prediction, axis=-2)
print('RMSE', metric.rmse(prediction, data_loader.test_y, threshold=0))
test_ratio=0.1)
test_start_index = data_loader.traffic_data.shape[
0] - data_loader.test_data.shape[0]
val_start_index = data_loader.traffic_data.shape[
0] - data_loader.test_data.shape[0] * 2
hm_obj = HM(c=int(params['CT']), p=int(params['PT']), t=int(params['TT']))
val_prediction = hm_obj.predict(val_start_index,
data_loader.traffic_data[:test_start_index],
time_fitness=data_loader.dataset.time_fitness)
test_prediction = hm_obj.predict(test_start_index,
data_loader.traffic_data,
time_fitness=data_loader.dataset.time_fitness)
val_rmse = metric.rmse(
val_prediction,
data_loader.traffic_data[val_start_index:test_start_index],
threshold=0)
test_rmse = metric.rmse(test_prediction, data_loader.test_data, threshold=0)
print(val_rmse, test_rmse)
nni.report_final_result({
'default': val_rmse,
'test-rmse': test_rmse,
})
forecast_step=1)
except Exception as e:
print('Converge failed with error', e)
print('Using last as prediction')
val_prediction = val_closeness[:, i, -1:, :]
test_prediction = data_loader.test_closeness[:, i, -1:, :]
val_prediction_collector.append(val_prediction)
test_prediction_collector.append(test_prediction)
print(
'Station', i,
metric.rmse(test_prediction,
data_loader.test_y[:, i:i + 1],
threshold=0))
val_prediction_collector = np.concatenate(val_prediction_collector, axis=-2)
test_prediction_collector = np.concatenate(test_prediction_collector, axis=-2)
val_rmse = metric.rmse(val_prediction_collector, val_y, threshold=0)
test_rmse = metric.rmse(test_prediction_collector,
data_loader.test_y,
threshold=0)
print(args['dataset'], args['city'], 'val_rmse', val_rmse)
print(args['dataset'], args['city'], 'test_rmse', test_rmse)
print('*************************************************************')
trend_feature=data_loader.test_trend,
laplace_matrix=graphBuilder.LM,
target=data_loader.test_y,
external_feature=data_loader.test_ef,
output_names=('prediction', ),
sequence_length=data_loader.test_sequence_len,
cache_volume=int(args['batch_size']),
)
test_prediction = prediction['prediction']
if de_normalizer:
test_prediction = de_normalizer(test_prediction)
data_loader.test_y = de_normalizer(data_loader.test_y)
test_rmse, test_mape = metric.rmse(prediction=test_prediction, target=data_loader.test_y, threshold=0),\
metric.mape(prediction=test_prediction, target=data_loader.test_y, threshold=0)
# Evaluate
val_loss = STMeta_obj.load_event_scalar('val_loss')
best_val_loss = min([e[-1] for e in val_loss])
if de_normalizer:
best_val_loss = de_normalizer(best_val_loss)
print('Best val result', best_val_loss)
print('Test result', test_rmse, test_mape)
time_consumption = [
val_loss[e][0] - val_loss[e - 1][0] for e in range(1, len(val_loss))
X_Test.append(data_loader.test_closeness[:, i, :, 0])
if int(params['PT']) > 0:
X_Train.append(train_period[:, i, :, 0])
X_Val.append(val_period[:, i, :, 0])
X_Test.append(data_loader.test_period[:, i, :, 0])
if int(params['TT']) > 0:
X_Train.append(train_trend[:, i, :, 0])
X_Val.append(val_trend[:, i, :, 0])
X_Test.append(data_loader.test_trend[:, i, :, 0])
X_Train = np.concatenate(X_Train, axis=-1)
X_Val = np.concatenate(X_Val, axis=-1)
X_Test = np.concatenate(X_Test, axis=-1)
model.fit(X_Train, train_y[:, i, 0])
p_val = model.predict(X_Val)
p_test = model.predict(X_Test)
prediction_test.append(p_test.reshape([-1, 1, 1]))
prediction_val.append(p_val.reshape([-1, 1, 1]))
prediction_test = np.concatenate(prediction_test, axis=-2)
prediction_val = np.concatenate(prediction_val, axis=-2)
print('Val RMSE', metric.rmse(prediction_val, val_y, threshold=0))
print('Test RMSE', metric.rmse(prediction_test, data_loader.test_y, threshold=0))
nni.report_final_result({'default': metric.rmse(prediction_val, val_y, threshold=0),
'test-rmse': metric.rmse(prediction_test, data_loader.test_y, threshold=0)})
results = []
for node in range(data_loader.station_number):
each_time = time.time()
model._code_version = str(
node) # to train different model for different node
model.fit(local_features=data_loader.train_local_features[node],
global_features=data_loader.train_global_features,
local_attn_states=data_loader.train_local_attn_states[node],
global_attn_states=data_loader.train_global_attn_states,
external_features=data_loader.train_external_features,
targets=data_loader.train_y[node],
sequence_length=data_loader.train_seq_len)
pred = model.predict(
local_features=data_loader.test_local_features[node],
global_features=data_loader.test_global_features,
local_attn_states=data_loader.test_local_attn_states[node],
global_attn_states=data_loader.test_global_attn_states,
external_features=data_loader.test_external_features,
targets=data_loader.test_y[node],
sequence_length=data_loader.test_seq_len)
results.append(
metric.rmse(pred['prediction'], data_loader.test_y[node], threshold=0))
seconds = int(time.time() - each_time)
print('[Node {}] - {}s - RMSE: {}'.format(node, seconds, results[-1]))
# randomize weights again for next node
model._session.run(model._variable_init)
print('Overall average RMSE: {}'.format(np.mean(results)))
train_period, val_period = SplitData.split_data(data_loader.train_period,
[0.9, 0.1])
train_trend, val_trend = SplitData.split_data(data_loader.train_trend,
[0.9, 0.1])
train_y, val_y = SplitData.split_data(data_loader.train_y, [0.9, 0.1])
hm_obj = HM(c=data_loader.closeness_len,
p=data_loader.period_len,
t=data_loader.trend_len)
test_prediction = hm_obj.predict(closeness_feature=data_loader.test_closeness,
period_feature=data_loader.test_period,
trend_feature=data_loader.test_trend)
val_prediction = hm_obj.predict(closeness_feature=val_closeness,
period_feature=val_period,
trend_feature=val_trend)
print('Test RMSE', metric.rmse(test_prediction,
data_loader.test_y,
threshold=0))
print('Val RMSE', metric.rmse(val_prediction, val_y, threshold=0))
nni.report_final_result({
'default':
metric.rmse(val_prediction, val_y, threshold=0),
'test-rmse':
metric.rmse(test_prediction, data_loader.test_y, threshold=0)
})
max_epoch=td_params['max_epoch'],
validate_ratio=0.1,
early_stop_method='t-test',
early_stop_length=td_params['early_stop_length'],
early_stop_patience=td_params['early_stop_patience'],
verbose=True,
save_model=True)
td_model.save(pretrain_model_name, global_step=0)
prediction = td_model.predict(
closeness_feature=data_loader.td_loader.test_closeness,
period_feature=data_loader.td_loader.test_period,
trend_feature=data_loader.td_loader.test_trend,
laplace_matrix=data_loader.td_loader.LM,
target=data_loader.td_loader.test_y,
external_feature=data_loader.td_loader.test_ef,
output_names=('prediction', ),
sequence_length=data_loader.td_loader.test_sequence_len,
cache_volume=td_params['batch_size'],
)
transfer_prediction = prediction['prediction']
test_rmse, test_mape = metric.rmse(prediction=td_de_normalizer(transfer_prediction),
target=td_de_normalizer(data_loader.td_loader.test_y), threshold=0), \
metric.mape(prediction=td_de_normalizer(transfer_prediction),
target=td_de_normalizer(data_loader.td_loader.test_y), threshold=0)
print('#################################################################')
print('Target Domain Transfer')
print(test_rmse, test_mape)
import numpy as np
from UCTB.model import ARIMA
from UCTB.dataset import NodeTrafficLoader
from UCTB.evaluation import metric
data_loader = NodeTrafficLoader(dataset='Bike', city='NYC', closeness_len=24, period_len=0, trend_len=0,
with_lm=False, normalize=False)
test_prediction_collector = []
for i in range(data_loader.station_number):
try:
model_obj = ARIMA(time_sequence=data_loader.train_closeness[:, i, -1, 0],
order=[6, 0, 1], seasonal_order=[0, 0, 0, 0])
test_prediction = model_obj.predict(time_sequences=data_loader.test_closeness[:, i, :, 0],
forecast_step=1)
except Exception as e:
print('Converge failed with error', e)
print('Using last as prediction')
test_prediction = data_loader.test_closeness[:, i, -1:, :]
test_prediction_collector.append(test_prediction)
print('Station', i, 'finished')
test_rmse = metric.rmse(np.concatenate(test_prediction_collector, axis=-2), data_loader.test_y, threshold=0)
print('test_rmse', test_rmse)
city=args['City'],
closeness_len=args['CT'],
period_len=args['PT'],
trend_len=args['TT'],
with_lm=False,
with_tpe=False,
normalize=False)
model = HMM(num_components=args['num_components'], n_iter=args['n_iter'])
train_closeness, val_closeness = SplitData.split_data(
data_loader.train_closeness, [0.9, 0.1])
train_period, val_period = SplitData.split_data(data_loader.train_period,
[0.9, 0.1])
train_trend, val_trend = SplitData.split_data(data_loader.train_trend,
[0.9, 0.1])
train_label, val_label = SplitData.split_data(data_loader.train_y, [0.9, 0.1])
model.fit(X=(train_closeness, train_period, train_trend), y=train_label)
val_results = model.predict(X=(val_closeness, val_period, val_trend))
test_results = model.predict(X=(data_loader.test_closeness,
data_loader.test_period,
data_loader.test_trend))
val_rmse = metric.rmse(val_results, val_label, threshold=0)
test_rmse = metric.rmse(test_results, data_loader.test_y, threshold=0)
print(args['Dataset'], args['City'], 'val_rmse', val_rmse)
print(args['Dataset'], args['City'], 'test_rmse', test_rmse)
# Evaluate
prediction = ST_MGCN_Obj.predict(traffic_flow=np.concatenate(
(np.transpose(data_loader.test_closeness, [0, 2, 1, 3]),
np.transpose(data_loader.test_period, [0, 2, 1, 3]),
np.transpose(data_loader.test_trend, [0, 2, 1, 3])),
axis=1),
laplace_matrix=graph_obj.LM,
external_feature=None,
sequence_length=data_loader.test_sequence_len,
output_names=['prediction'],
cache_volume=int(args['BatchSize']))
test_rmse = metric.rmse(prediction=data_loader.normalizer.min_max_denormal(
prediction['prediction']),
target=data_loader.normalizer.min_max_denormal(
data_loader.test_y),
threshold=0)
print('Test result', test_rmse)
val_loss = ST_MGCN_Obj.load_event_scalar('val_loss')
best_val_loss = min([e[-1] for e in val_loss])
best_val_loss = data_loader.normalizer.min_max_denormal(best_val_loss)
print('Best val result', best_val_loss)
time_consumption = [
val_loss[e][0] - val_loss[e - 1][0] for e in range(1, len(val_loss))
prediction = sd_model.predict(
closeness_feature=data_loader.sd_loader.test_closeness,
period_feature=data_loader.sd_loader.test_period,
trend_feature=data_loader.sd_loader.test_trend,
laplace_matrix=data_loader.sd_loader.LM,
target=data_loader.sd_loader.test_y,
external_feature=data_loader.sd_loader.test_ef,
output_names=('prediction', ),
sequence_length=data_loader.sd_loader.test_sequence_len,
cache_volume=sd_params['batch_size'],
)
test_prediction = prediction['prediction']
test_rmse, test_mape = metric.rmse(prediction=sd_de_normalizer(test_prediction),
target=sd_de_normalizer(data_loader.sd_loader.test_y), threshold=rmse_threshold), \
metric.mape(prediction=sd_de_normalizer(test_prediction),
target=sd_de_normalizer(data_loader.sd_loader.test_y), threshold=0)
print('#################################################################')
print('Source Domain Result')
print(test_rmse, test_mape)
td_model.load(pretrain_model_name)
prediction = td_model.predict(
closeness_feature=data_loader.td_loader.test_closeness,
period_feature=data_loader.td_loader.test_period,
trend_feature=data_loader.td_loader.test_trend,
laplace_matrix=data_loader.td_loader.LM,
target=data_loader.td_loader.test_y,
