def test_ctc_encoder_train_and_network_output_to_labels():
# test CTC encoder in training loop and CTCEncoder.network_output_to_labels
a = C.sequence.input_variable(10)
labels = ['a', 'b', 'c']
encoder = CTCEncoder(labels)
labels_tensor = C.sequence.input_variable(len(
encoder.classes_)) # number of classes = 4
input_tensor = C.sequence.input_variable(100)
prediction_tensor = Dense(4)(Recurrence(LSTM(100))(
C.ones_like(input_tensor)))
labels_graph = C.labels_to_graph(labels_tensor)
fb = C.forward_backward(labels_graph,
prediction_tensor,
blankTokenId=encoder.blankTokenId)
ground_truth = ['a', 'b', 'b', 'b', 'c']
seq_length = 10 # must be the same length as the sequence length in network_out
pred = np.array([
[0., 2., 0., 0.],
[0., 2., 0., 0.],
[0., 0., 2., 0.],
[2., 0., 0., 0.],
[0., 0., 2., 0.],
[2., 0., 0., 0.],
[0., 0., 2., 0.],
[2., 0., 0., 0.],
[0., 0., 0., 2.],
[0., 0., 0., 2.],
]).astype(np.float32)
n = np.random.random((10, 100)).astype(np.float32)
# result = fb.eval({labels_tensor: [encoder.transform(ground_truth, seq_length=seq_length)],
# input_tensor: [n]})
# print(result)
adam = C.adam(prediction_tensor.parameters, 0.01, 0.912)
trainer = C.Trainer(prediction_tensor, (fb, ), [adam])
for i in range(300):
trainer.train_minibatch({
labels_tensor:
[encoder.transform(ground_truth, seq_length=seq_length)],
input_tensor: [n]
})
# print(trainer.previous_minibatch_loss_average)
result = prediction_tensor.eval({input_tensor: [n]})
assert encoder.network_output_to_labels(result[0],
squash_repeat=True) == ground_truth
input_tensor = C.sequence.input_variable(input_dim)
target_tensor = C.input_variable(1)
hidden = QRNN(window=2, hidden_dim=hidden_dim)(input_tensor)
# hidden = Recurrence(LSTM(hidden_dim))(input_tensor)
prediction = Dense(1)(C.sequence.last(hidden))
loss = C.squared_error(prediction, target_tensor)
sgd_m = C.momentum_sgd(prediction.parameters, 0.1, 0.912)
trainer = C.Trainer(prediction, (loss, ), [sgd_m])
n_epoch = 50
minibatch_size = 30
start = time.time()
for epoch in range(n_epoch):
for i in range(0, len(x), minibatch_size):
lbound, ubound = i, i + minibatch_size
x_mini = x[lbound:ubound]
y_mini = y[lbound:ubound]
trainer.train_minibatch({input_tensor: x_mini, target_tensor: y_mini})
print(f"loss: {trainer.previous_minibatch_loss_average}")
print(f"Training completed in {time.time() - start}s")
n = np.random.randint(2, size=(6, input_dim)).astype(np.float32)
print(prediction.eval({input_tensor: [n]}))
print(n.sum())
