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,