def ran_a_test():
a = ARMA([-0.5, 0.11], [], 0.5, "uni")
time_series = [a.generater.next() for i in range(2000)]
p = ArPredicter(len(a.alphas), max_x = max(time_series),)
errors = []
for index, x in enumerate(time_series):
if index < p.min_ob:
p.predict_and_fit(x)
elif random.random() > missing_percent:
rec_x = p.predict_and_fit(x)
errors.append(rec_x - x)
else:
p.predict_and_fit('*')
mse = sum(map(lambda x: x**2, errors)) / len(errors)
result['errors'].append(errors)
result['mses'].append(mse)
def run_a_test():
#a = ARMA([0.3, -0.4, 0.4, -0.5, 0.6], [], 0.3, noise_type)
a = ARMA([-0.5, 0.11], [], 0.5, noise_type)
time_series = [a.generater.next() for i in range(2000)]
if_missing = [
1 if random.random() > missing_rate or time_series.index(t) < 6
else 0 for t in time_series
]
time_series = [
t if flag == 1 else 0 for t, flag in zip(time_series, if_missing)
]
missing_indexs = [
index for index, flag in enumerate(if_missing) if flag == 0
]
p = ArPredicter(a.p, time_series, missing_indexs)
result['errors'].append(p.errors)
result['mses'].append(p.mse)
def main(_):
flags_obj = tf.flags.FLAGS
euler_graph = tf_euler.dataset.get_dataset(flags_obj.dataset)
euler_graph.load_graph()
dims = [flags_obj.hidden_dim, flags_obj.hidden_dim]
if flags_obj.run_mode == 'train':
metapath = [euler_graph.train_edge_type]
else:
metapath = [euler_graph.all_edge_type]
num_steps = int((euler_graph.total_size + 1) // flags_obj.batch_size *
flags_obj.num_epochs)
model = ARMA(dims,
metapath,
euler_graph.feature_idx,
euler_graph.feature_dim,
euler_graph.label_idx,
euler_graph.label_dim,
num_layers=flags_obj.layers,
K=flags_obj.K)
params = {
'train_node_type': euler_graph.train_node_type[0],
'batch_size': flags_obj.batch_size,
'optimizer': flags_obj.optimizer,
'learning_rate': flags_obj.learning_rate,
'log_steps': flags_obj.log_steps,
'model_dir': flags_obj.model_dir,
'id_file': euler_graph.id_file,
'infer_dir': flags_obj.model_dir,
'total_size': euler_graph.total_size,
'total_step': num_steps
}
config = tf.estimator.RunConfig(log_step_count_steps=None)
model_estimator = NodeEstimator(model, params, config)
if flags_obj.run_mode == 'train':
model_estimator.train()
elif flags_obj.run_mode == 'evaluate':
model_estimator.evaluate()
elif flags_obj.run_mode == 'infer':
model_estimator.infer()
else:
raise ValueError('Run mode not exist!')
