def test_batch_flow_bucket():
from fake_data import generate
x_data, y_data, ws_input, ws_target = generate(size=10000)
flow = batch_flow_bucket([x_data, y_data], [ws_input, ws_target], 4, debug=True)
for _ in range(10):
x, xl, y, yl = next(flow)
print(x.shape, y.shape, xl.shape, yl.shape)
def test_batch_flow():
"""test batch_flow function"""
from fake_data import generate
x_data, y_data, ws_input, ws_target = generate(size=10000)
flow = batch_flow([x_data, y_data], [ws_input, ws_target], 4)
x, xl, y, yl = next(flow)
print(x.shape, y.shape, xl.shape, yl.shape)
def test():
"""单元测试"""
from fake_data import generate
from data_utils import batch_flow
from tqdm import tqdm
x_data, y_data, ws_input, ws_target = generate(size=10000)
batch_size = 4
n_epoch = 10
steps = int(len(x_data) / batch_size) + 1
config = tf.ConfigProto(device_count={
'CPU': 1,
'GPU': 0
},
allow_soft_placement=True,
log_device_placement=False)
tf.reset_default_graph()
with tf.Graph().as_default():
random.seed(0)
np.random.seed(0)
tf.set_random_seed(0)
with tf.Session(config=config) as sess:
model = Discriminative(len(ws_input), batch_size=batch_size)
init = tf.global_variables_initializer()
sess.run(init)
# print(sess.run(model.input_layer.kernel))
# exit(1)
for epoch in range(1, n_epoch + 1):
costs = []
flow = batch_flow([x_data, y_data], [ws_input, ws_target],
batch_size)
bar = tqdm(range(steps),
desc='epoch {}, loss=0.000000'.format(epoch))
for _ in bar:
x, xl, y, yl = next(flow)
targets = np.array([(0, 1) for x in range(len(y))])
cost = model.train(sess, x, xl, y, yl, targets)
print(x.shape, xl.shape)
print('cost.shape, cost', cost.shape, cost)
exit(1)
costs.append(cost)
bar.set_description('epoch {} loss={:.6f}'.format(
epoch, np.mean(costs)))
def test(bidirectional, cell_type, depth,
attention_type, use_residual, use_dropout, time_major):
"""测试不同参数在生成的假数据上的运行结果"""
# 获取一些假数据
x_data, y_data, ws_input, ws_target = generate(size=10000)
# 训练部分
split = int(len(x_data) * 0.8)
x_train, x_test, y_train, y_test = (
x_data[:split], x_data[split:], y_data[:split], y_data[split:])
n_epoch = 2
batch_size = 32
steps = int(len(x_train) / batch_size) + 1
config = tf.ConfigProto(
device_count={'CPU': 1, 'GPU': 0},
allow_soft_placement=True,
log_device_placement=False
)
save_path = '/tmp/s2ss.ckpt'
tf.reset_default_graph()
with tf.Graph().as_default():
random.seed(0)
np.random.seed(0)
tf.set_random_seed(0)
with tf.Session(config=config) as sess:
model = SequenceToSequence(
input_vocab_size=len(ws_input),
target_vocab_size=len(ws_target),
batch_size=batch_size,
learning_rate=0.001,
bidirectional=bidirectional,
cell_type=cell_type,
depth=depth,
attention_type=attention_type,
use_residual=use_residual,
use_dropout=use_dropout,
time_major=time_major,
hidden_units=64,
embedding_size=64,
parallel_iterations=1 # for test
)
init = tf.global_variables_initializer()
sess.run(init)
# print(sess.run(model.input_layer.kernel))
# exit(1)
for epoch in range(1, n_epoch + 1):
costs = []
flow = batch_flow(
[x_train, y_train], [ws_input, ws_target], batch_size
)
bar = tqdm(range(steps),
desc='epoch {}, loss=0.000000'.format(epoch))
for _ in bar:
x, xl, y, yl = next(flow)
cost = model.train(sess, x, xl, y, yl)
costs.append(cost)
bar.set_description('epoch {} loss={:.6f}'.format(
epoch,
np.mean(costs)
))
model.save(sess, save_path)
# 测试部分
tf.reset_default_graph()
model_pred = SequenceToSequence(
input_vocab_size=len(ws_input),
target_vocab_size=len(ws_target),
batch_size=1,
mode='decode',
beam_width=5,
bidirectional=bidirectional,
cell_type=cell_type,
depth=depth,
attention_type=attention_type,
use_residual=use_residual,
use_dropout=use_dropout,
time_major=time_major,
hidden_units=64,
embedding_size=64,
parallel_iterations=1 # for test
)
init = tf.global_variables_initializer()
with tf.Session(config=config) as sess:
sess.run(init)
model_pred.load(sess, save_path)
bar = batch_flow([x_test, y_test], [ws_input, ws_target], 1)
t = 0
for x, xl, y, yl in bar:
pred = model_pred.predict(
sess,
np.array(x),
np.array(xl)
)
print(ws_input.inverse_transform(x[0]))
print(ws_target.inverse_transform(y[0]))
print(ws_target.inverse_transform(pred[0]))
t += 1
if t >= 3:
break
tf.reset_default_graph()
model_pred = SequenceToSequence(
input_vocab_size=len(ws_input),
target_vocab_size=len(ws_target),
batch_size=1,
mode='decode',
beam_width=0,
bidirectional=bidirectional,
cell_type=cell_type,
depth=depth,
attention_type=attention_type,
use_residual=use_residual,
use_dropout=use_dropout,
time_major=time_major,
hidden_units=64,
embedding_size=64,
parallel_iterations=1 # for test
)
init = tf.global_variables_initializer()
with tf.Session(config=config) as sess:
sess.run(init)
model_pred.load(sess, save_path)
bar = batch_flow([x_test, y_test], [ws_input, ws_target], 1)
t = 0
for x, xl, y, yl in bar:
pred = model_pred.predict(
sess,
np.array(x),
np.array(xl)
)
print(ws_input.inverse_transform(x[0]))
print(ws_target.inverse_transform(y[0]))
print(ws_target.inverse_transform(pred[0]))
t += 1
if t >= 3:
break
# return last train loss
return np.mean(costs)
def test(bidirectional, cell_type, depth, attention_type):
"""测试并展示attention图
"""
from tqdm import tqdm
from fake_data import generate
# 获取一些假数据
x_data, y_data, ws_input, ws_target = generate(size=10000)
# 训练部分
split = int(len(x_data) * 0.9)
x_train, x_test, y_train, y_test = (x_data[:split], x_data[split:],
y_data[:split], y_data[split:])
n_epoch = 2
batch_size = 32
steps = int(len(x_train) / batch_size) + 1
config = tf.ConfigProto(device_count={
'CPU': 1,
'GPU': 0
},
allow_soft_placement=True,
log_device_placement=False)
save_path = '/tmp/s2ss_atten.ckpt'
with tf.Graph().as_default():
model = SequenceToSequence(input_vocab_size=len(ws_input),
target_vocab_size=len(ws_target),
batch_size=batch_size,
learning_rate=0.001,
bidirectional=bidirectional,
cell_type=cell_type,
depth=depth,
attention_type=attention_type,
parallel_iterations=1)
init = tf.global_variables_initializer()
with tf.Session(config=config) as sess:
sess.run(init)
for epoch in range(1, n_epoch + 1):
costs = []
flow = batch_flow([x_train, y_train], [ws_input, ws_target],
batch_size)
bar = tqdm(range(steps),
desc='epoch {}, loss=0.000000'.format(epoch))
for _ in bar:
x, xl, y, yl = next(flow)
cost = model.train(sess, x, xl, y, yl)
costs.append(cost)
bar.set_description('epoch {} loss={:.6f}'.format(
epoch, np.mean(costs)))
model.save(sess, save_path)
# attention 展示 不能用 beam search 的
# 所以这里只是用 greedy
with tf.Graph().as_default():
model_pred = SequenceToSequence(input_vocab_size=len(ws_input),
target_vocab_size=len(ws_target),
batch_size=1,
mode='decode',
beam_width=0,
bidirectional=bidirectional,
cell_type=cell_type,
depth=depth,
attention_type=attention_type,
parallel_iterations=1)
init = tf.global_variables_initializer()
with tf.Session(config=config) as sess:
sess.run(init)
model_pred.load(sess, save_path)
pbar = batch_flow([x_test, y_test], [ws_input, ws_target], 1)
t = 0
for x, xl, y, yl in pbar:
pred, atten = model_pred.predict(sess,
np.array(x),
np.array(xl),
attention=True)
ox = ws_input.inverse_transform(x[0])
oy = ws_target.inverse_transform(y[0])
op = ws_target.inverse_transform(pred[0])
print(ox)
print(oy)
print(op)
fig, ax = plt.subplots()
cax = ax.matshow(atten.reshape(
[atten.shape[0], atten.shape[2]]),
cmap=cm.coolwarm)
ax.set_xticks(np.arange(len(ox)))
ax.set_yticks(np.arange(len(op)))
ax.set_xticklabels(ox)
ax.set_yticklabels(op)
fig.colorbar(cax)
plt.show()
print('-' * 30)
t += 1
if t >= 10:
break
def test_batch_flow():
from fake_data import generate
x_data, y_data, ws_input, ws_target = generate(size=10000)
flow = batch_flow([x_data, y_data], [ws_input, ws_target], 4)
x, x1, y, y1 = next(flow)
print(x.shape, y.shape, x1.shape, y1.shape)
def test(bidirectional, cell_type, depth, use_residual, use_dropout,
output_project_active, crf_loss):
"""测试不同参数在生成的假数据上的运行结果"""
# 获取一些假数据
x_data, y_data, ws_input, ws_target = generate(size=10000, same_len=True)
# 训练部分
split = int(len(x_data) * 0.8)
x_train, x_test, y_train, y_test = (x_data[:split], x_data[split:],
y_data[:split], y_data[split:])
n_epoch = 1
batch_size = 32
steps = int(len(x_train) / batch_size) + 1
config = tf.ConfigProto(device_count={
'CPU': 1,
'GPU': 0
},
allow_soft_placement=True,
log_device_placement=False)
save_path = '/tmp/s2ss_crf.ckpt'
tf.reset_default_graph()
with tf.Graph().as_default():
random.seed(0)
np.random.seed(0)
tf.set_random_seed(0)
with tf.Session(config=config) as sess:
model = RNNCRF(input_vocab_size=len(ws_input),
target_vocab_size=len(ws_target),
max_decode_step=100,
batch_size=batch_size,
learning_rate=0.001,
bidirectional=bidirectional,
cell_type=cell_type,
depth=depth,
use_residual=use_residual,
use_dropout=use_dropout,
output_project_active=output_project_active,
hidden_units=64,
embedding_size=64,
parallel_iterations=1,
crf_loss=crf_loss)
init = tf.global_variables_initializer()
sess.run(init)
# print(sess.run(model.input_layer.kernel))
# exit(1)
for epoch in range(1, n_epoch + 1):
costs = []
flow = batch_flow([x_train, y_train], [ws_input, ws_target],
batch_size)
bar = tqdm(range(steps),
desc='epoch {}, loss=0.000000'.format(epoch))
for _ in bar:
x, xl, y, yl = next(flow)
cost = model.train(sess, x, xl, y, yl)
costs.append(cost)
bar.set_description('epoch {} loss={:.6f}'.format(
epoch, np.mean(costs)))
model.save(sess, save_path)
# 测试部分
tf.reset_default_graph()
model_pred = RNNCRF(input_vocab_size=len(ws_input),
target_vocab_size=len(ws_target),
max_decode_step=100,
batch_size=batch_size,
mode='decode',
bidirectional=bidirectional,
cell_type=cell_type,
depth=depth,
use_residual=use_residual,
use_dropout=use_dropout,
output_project_active=output_project_active,
hidden_units=64,
embedding_size=64,
parallel_iterations=1,
crf_loss=crf_loss)
init = tf.global_variables_initializer()
with tf.Session(config=config) as sess:
sess.run(init)
model_pred.load(sess, save_path)
flow = batch_flow([x_test, y_test], [ws_input, ws_target], batch_size)
pbar = tqdm(range(100))
acc = []
for i in pbar:
x, xl, y, yl = next(flow)
pred = model_pred.predict(sess, np.array(x), np.array(xl))
for j in range(batch_size):
right = np.sum(y[j][:yl[j]] == pred[j][:yl[j]])
acc.append(right / yl[j])
if i < 3:
print(ws_input.inverse_transform(x[0]))
print(ws_target.inverse_transform(y[0]))
print(ws_target.inverse_transform(pred[0]))
else:
pbar.set_description('acc: {}'.format(np.mean(acc)))
