def input_fn():
with tf.device('/cpu:0'):
if is_train:
dataset = train_dataset(opts.data_dir, fashion=opts.fashion)
dataset = dataset.apply(tf.contrib.data.shuffle_and_repeat(buffer_size=5 * opts.batch_size, count=None))
else:
dataset = test_dataset(opts.data_dir, fashion=opts.fashion)
dataset = dataset.batch(batch_size=opts.batch_size)
iterator = dataset.make_one_shot_iterator()
return iterator.get_next()
def main(_):
print(
"==============================================================================="
)
print("The input_dim is", FLAGS.input_dim, "The hidden_dim is",
FLAGS.hidden_dim)
print("The output_dim is", FLAGS.output_dim, "The keep_prob is",
FLAGS.keep_prob)
print("The batch_size is", FLAGS.batch_size, "The test is",
FLAGS.test_batch_size)
print("The model is", FLAGS.model, "The number of layer is", FLAGS.layer)
print("The truncated number is", FLAGS.trun_num, "The reverse is",
FLAGS.reverse)
X_train, y_train, X_test, y_test, _, cpu_load_std = read_data(
FLAGS.data_path, FLAGS.input_dim, FLAGS.output_dim, FLAGS.input_dim)
with open("./data/axp0.pkl", 'rb') as f:
axp0 = pickle.load(f)
with open("./data/axp7.pkl", 'rb') as f:
axp7 = pickle.load(f)
with open("./data/sahara.pkl", 'rb') as f:
sahara = pickle.load(f)
with open("./data/themis.pkl", 'rb') as f:
themis = pickle.load(f)
_, _, X_axp0_test, y_axp0_test, std_axp0 = test_dataset(
axp0, FLAGS.input_dim, FLAGS.output_dim, FLAGS.input_dim)
_, _, X_axp7_test, y_axp7_test, std_axp7 = test_dataset(
axp7, FLAGS.input_dim, FLAGS.output_dim, FLAGS.input_dim)
_, _, X_sahara_test, y_sahara_test, std_sahara = test_dataset(
sahara, FLAGS.input_dim, FLAGS.output_dim, FLAGS.input_dim)
_, _, X_themis_test, y_themis_test, std_themis = test_dataset(
themis, FLAGS.input_dim, FLAGS.output_dim, FLAGS.input_dim)
train_data_len = X_train.shape[1]
train_len, train_index = truncated_index(train_data_len, FLAGS.trun_num,
FLAGS.reverse)
print("train length", train_len)
print(train_index)
with tf.Graph().as_default(), tf.Session() as session:
with tf.variable_scope("model", reuse=None):
m_train = RNNModel(is_training=True,
batch_size=FLAGS.batch_size,
length=train_len)
with tf.variable_scope("model", reuse=True):
m_test = RNNModel(is_training=False,
batch_size=FLAGS.batch_size,
length=len(y_test[0]))
m_new_test = RNNModel(is_training=False,
batch_size=FLAGS.test_batch_size,
length=len(y_test[0]))
tf.initialize_all_variables().run()
#log_a = Log('http://localhost:8120','modelA')
# pastalog --serve 8120
scale = cpu_load_std**2
test_best = 0.0
training_time = []
for i in range(FLAGS.epoch):
if i < FLAGS.epoch / 3:
lr_decay = 1
elif i < FLAGS.epoch * 2 / 3:
lr_decay = 0.1
else:
lr_decay = 0.01
m_train.assign_lr(session, FLAGS.lr * lr_decay)
train_loss_list = []
train_state_list = []
start = time.time()
for j in range(FLAGS.trun_num):
train_loss, train_state = run_train_epoch(
session, m_train, X_train[:, train_index[j], :],
y_train[:, train_index[j], :], m_train.train_op)
train_loss_list.append(train_loss)
if FLAGS.reverse:
if j == 0:
train_state_list.append(train_state)
else:
if j == FLAGS.trun_num - 1:
train_state_list.append(train_state)
finish = time.time()
training_time.append(finish - start)
test_loss, _ = run_test_epoch(session, m_test, X_test, y_test,
tf.no_op(), train_state_list[0])
axp0_loss = run_new_load(session, m_new_test, X_axp0_test,
y_axp0_test, tf.no_op())
axp7_loss = run_new_load(session, m_new_test, X_axp7_test,
y_axp7_test, tf.no_op())
sahara_loss = run_new_load(session, m_new_test, X_sahara_test,
y_sahara_test, tf.no_op())
themis_loss = run_new_load(session, m_new_test, X_themis_test,
y_themis_test, tf.no_op())
if i == 0:
test_best = test_loss
if test_loss < test_best:
test_best = test_loss
# print("epoch:%3d, lr %.5f, train_loss_1 %.6f, train_loss_2 %.6f, test_loss %.6f" %
# (i + 1, session.run(m_train.lr), train_loss_1*scale,
# train_loss_2*scale, test_loss*scale))
#print(np.asarray(train_loss_list)*scale)
print(
"epoch:%3d, lr %.5f, train_loss %.6f, test_loss %.6f, speed %.2f seconds/epoch"
% (i + 1, session.run(m_train.lr), np.mean(train_loss_list) *
scale, test_loss * scale, training_time[i]))
print("axp0 loss %.6f, axp7 loss %.6f" %
(axp0_loss * std_axp0**2, axp7_loss * std_axp7**2))
print("sahara loss %.6f, themis loss %.6f" %
(sahara_loss * std_sahara**2, themis_loss * std_themis**2))
#log_a.post("trainLoss", value=float(train_loss), step=i)
#log_a.post("testLoss", value=float(test_loss), step=i)
if i == FLAGS.epoch - 1:
print("Best test loss %.6f" % (test_best * scale))
print("Average %.4f seconds for one epoch" %
(np.mean(training_time)))
print("The input_dim is", FLAGS.input_dim, "The hidden_dim is",
FLAGS.hidden_dim)
print("The output_dim is", FLAGS.output_dim, "The keep_prob is",
FLAGS.keep_prob)
print("The batch_size is", FLAGS.batch_size, "The test is",
FLAGS.test_batch_size)
print("The keep_prob is", FLAGS.keep_prob, "The batch_size is",
FLAGS.batch_size)
print("The model is", FLAGS.model, "The number of layer is", FLAGS.layer)
print("The truncated number is", FLAGS.trun_num, "The reverse is",
FLAGS.reverse)
print(
"==============================================================================="
)
def main(_):
print(
"==============================================================================="
)
print("The input_dim is", FLAGS.input_dim, "The hidden_dim is",
FLAGS.hidden_dim)
print("The output_dim is", FLAGS.output_dim)
print("The batch_size is", FLAGS.batch_size, "The test is ",
FLAGS.test_batch_size)
print("The data_path is", FLAGS.data_path)
X_train, y_train, X_test, y_test, _, cpu_load_std = read_data(
FLAGS.data_path, FLAGS.input_dim, FLAGS.output_dim, FLAGS.input_dim)
with open("./data/axp0.pkl", 'rb') as f:
axp0 = pickle.load(f)
with open("./data/axp7.pkl", 'rb') as f:
axp7 = pickle.load(f)
with open("./data/sahara.pkl", 'rb') as f:
sahara = pickle.load(f)
with open("./data/themis.pkl", 'rb') as f:
themis = pickle.load(f)
_, _, X_axp0, y_axp0, std_axp0 = test_dataset(axp0, FLAGS.input_dim,
FLAGS.output_dim,
FLAGS.input_dim)
_, _, X_axp7, y_axp7, std_axp7 = test_dataset(axp7, FLAGS.input_dim,
FLAGS.output_dim,
FLAGS.input_dim)
_, _, X_sahara, y_sahara, std_sahara = test_dataset(
sahara, FLAGS.input_dim, FLAGS.output_dim, FLAGS.input_dim)
_, _, X_themis, y_themis, std_themis = test_dataset(
themis, FLAGS.input_dim, FLAGS.output_dim, FLAGS.input_dim)
inSize = FLAGS.input_dim
resSize = FLAGS.hidden_dim
rho = 0.1
# rho = 0.9
# cr = 0.05
Win = np.float32(np.random.rand(inSize, resSize) / 5 - 0.1)
# Win = np.float32(np.random.rand(inSize, resSize) - 0.5)
N = resSize * resSize
W = np.random.rand(N) - 0.5
# zero_index = np.random.permutation(N)[int(N * cr * 1.0):]
# W[zero_index] = 0
W = W.reshape((resSize, resSize))
rhoW = max(abs(linalg.eig(W)[0]))
W *= rho / rhoW
W = np.float32(W)
with tf.Graph().as_default(), tf.Session() as session:
with tf.variable_scope("model", reuse=None):
m_train = ESN(is_training=True,
batch_size=FLAGS.batch_size,
length=len(y_train[0]))
with tf.variable_scope("model", reuse=True):
m_test = ESN(is_training=False,
batch_size=FLAGS.batch_size,
length=len(y_test[0]))
m_new_test = ESN(is_training=False,
batch_size=FLAGS.test_batch_size,
length=len(y_test[0]))
tf.initialize_all_variables().run()
#log_a = Log('http://localhost:8120','modelA')
# pastalog --serve 8120
scale = cpu_load_std**2
train_best = test_best = 0.0
for i in range(FLAGS.epoch):
if i < FLAGS.epoch / 3:
lr_decay = 1
elif i < FLAGS.epoch * 2 / 3:
lr_decay = 0.1
else:
lr_decay = 0.01
m_train.assign_lr(session, FLAGS.lr * lr_decay)
train_loss, train_state = run_train_epoch(session, m_train, Win, W,
X_train, y_train[:,
50:, :],
m_train.train_op)
test_loss, _ = run_test_epoch(session, m_test, Win, W, X_test,
y_test, tf.no_op(), train_state)
axp0_loss = run_new_load(session, m_new_test, Win, W, X_axp0,
y_axp0, tf.no_op())
axp7_loss = run_new_load(session, m_new_test, Win, W, X_axp7,
y_axp7, tf.no_op())
sahara_loss = run_new_load(session, m_new_test, Win, W, X_sahara,
y_sahara, tf.no_op())
themis_loss = run_new_load(session, m_new_test, Win, W, X_themis,
y_themis, tf.no_op())
if i == 0:
train_best = train_loss
test_best = test_loss
if train_loss < train_best:
train_best = train_loss
if test_loss < test_best:
test_best = test_loss
print(
"epoch:%3d, learning rate %.5f, train_loss %.6f, test_loss %.6f"
% (i + 1, session.run(
m_train.lr), train_loss * scale, test_loss * scale))
print("axp0 loss %.6f, axp7 loss %.6f" %
(axp0_loss * std_axp0**2, axp7_loss * std_axp7**2))
print("sahara loss %.6f, themis loss %.6f" %
(sahara_loss * std_sahara**2, themis_loss * std_themis**2))
#log_a.post("trainLoss", value=float(train_loss), step=i)
#log_a.post("testLoss", value=float(test_loss), step=i)
if i == FLAGS.epoch - 1:
print("Best train, test loss %.6f %.6f" %
(train_best * scale, test_best * scale))
print("The input_dim is", FLAGS.input_dim, "The hidden_dim is",
FLAGS.hidden_dim)
print("The output_dim is", FLAGS.output_dim)
print("The batch_size is", FLAGS.batch_size, "The test is ",
FLAGS.test_batch_size)
print("The data_path is", FLAGS.data_path)
print(
"==============================================================================="
)