def main():
print 'Loading Data'
x = cPickle.load(open('english_matrices.pkl', 'rb'))
y = cPickle.load(open('chinese_matrices.pkl', 'rb'))
print 'Done'
# x = np.random.random((10, 10, 50, 1))
# y = np.random.random((10, 10, 50, 1))
encoder_lstm = LSTM(50, 100, 50)
encoder_lstm.load_weights('encoder.pkl')
outputs = []
for i in range(10000):
outputs.append(encoder_lstm.predict(x[i]))
# for _ in range(10):
# for i in range(20):
# idx_start = i*500
# idx_end = min((i+1)*500, len(x))
# sys.stdout.write('\n\nTraining Data %d - %d' % (idx_start, idx_end))
# train(encoder_lstm, x[idx_start:idx_end], y[idx_start:idx_end][0], 50, 'encoder')
# encoder_lstm.save_weights('encoder.pkl')
# outputs = encoder_lstm.predict(x[:10000])
# encoder_lstm.save_weights('encoder.pkl')
embed()
decoder_lstm = LSTM(50, 100, 50)
for _ in range(4):
for i in range(20):
idx_start = i * 500
idx_end = min((i + 1) * 500, len(x))
sys.stdout.write('\n\nTraining Data %d - %d' % (idx_start, idx_end))
train(decoder_lstm, outputs[idx_start:idx_end], y[idx_start:idx_end], 50, 'decoder')
decoder_lstm.save_weights('decoder.pkl')
# persist preprocessing steps
with open('processor.json', 'w') as f:
f.write(jsonpickle.dumps(TEXT))
# persist model
rand_text, _ = next(iter(train_iter))
torch_onnx.export(net,
rand_text[[0]], # Keep batch size to 1
'model.onnx',
verbose=False,
input_names=['input1'],
output_names=['output1'],
dynamic_axes={'input1': {0: 'batch'},
'output1': {0: 'batch'}})
# calculate set of quality metrics
y_pred, y_true = net.predict(val_iter)
f1_metric = f1_score(y_true, y_pred)
accuracy_metric = accuracy_score(y_true, y_pred)
print(classification_report(y_true, y_pred))
# write metrics
if not os.path.exists("metrics"):
os.mkdir("metrics")
with open("metrics/f1.metric", "w+") as f:
json.dump(f1_metric, f)
with open("metrics/accuracy.metric", "w+") as f:
json.dump(accuracy_metric, f)
torch.save(
{
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': model.optimizer.state_dict(),
'loss': mean_loss,
}, 'saved_models/lstm_adam_b10_lb168_model')
elif epoch - best_loss[1] > patience:
still_learning = False
epoch += 1
# get just one sample for prediction
data_pred, target_pred = next(iter(test_loader))
# prepare data for comparison
pred = model.predict(Variable(data_pred), look_ahead)
target_scaled = scaler.inverse_transform(target_pred[0, :].detach().view(
-1, 1).numpy())
pred_scaled = scaler.inverse_transform(pred[0, :].detach().view(-1, 1).numpy())
# compute MSE and MAE
train_loader, test_loader, scaler = build_loader(test_ratio,
look_back,
look_ahead,
batch_size=1)
mse_losses = []
mae_losses = []
residuals = []
for data, target in train_loader:
mse_loss, mae_loss, resid = model.step(data,
X_train, Y_train, X_val, Y_val = train_test_splits(X, Y, N, 8)
model = LSTM(num_classes=NUM_CLASSES,
max_seq_len=MAX_SEQ_LEN,
num_features=NUM_FEATURES,
learning_rate=0.0003,
hidden_units=64,
model_path=model_path)
print 'epoch,mean_loss,train_acc,val_acc'
for epoch in range(500):
epoch_loss = 0
for x_batch, y_batch in iter_batches(X_train, Y_train, BATCH_SIZE):
epoch_loss += model.train_on_batch(x_batch, y_batch)
epoch_loss = epoch_loss * 1.0 / (N / BATCH_SIZE)
print '%s,%s,%s,%s' % (epoch, epoch_loss,
accuracy(model.predict(X_train),
from_one_hot(Y_train)),
accuracy(model.predict(X_val), from_one_hot(Y_val)))
# TODO - CLEAN THIS SHIT UP
print '=== BASELINE ACC'
Y_val = from_one_hot(Y_val)
N1 = np.sum(Y_val)
N0 = len(Y_val) - N1
print '\t random (freqs): %s' % (max(N0, N1) * 1.0 / (N0 + N1))
Y_hat = model.predict(X_val)
random.shuffle(Y_hat)
print '\t random (permutations): %s' % accuracy(Y_hat, Y_val)
parser = argparse.ArgumentParser(description='Test.')
parser.add_argument(nargs='*',
action='store',
dest='input',
type=str,
help='The text to parse.')
args = parser.parse_args()
sentence = args.input
english_dict = cPickle.load(open('english_dictionary.pkl'))
chinese_dict = cPickle.load(open('chinese_dictionary.pkl'))
encoder = LSTM(50, 100, 50)
encoder.load_weights('encoder.pkl')
decoder = LSTM(50, 100, 50)
mat = []
for word in sentence:
mat.append(english_dict[word])
mat = np.array(mat)
mat = mat.reshape((mat.shape[0], mat.shape[1], 1))
output = encoder.predict(mat)
final = decoder.predict([output[-1].v], output[-1].h)
translated_sentence = ''
for word in final:
translated_sentence += findWord(word.v, chinese_dict)
print translated_sentence
hidden_units=64,
model_path=model_path)
print 'epoch,mean_loss,train_acc,val_acc'
xaxis = []
yaxis = []
for epoch in range(500):
epoch_loss = 0
for x_batch, y_batch in iter_batches(X_train, Y_train, BATCH_SIZE):
epoch_loss += model.train_on_batch(x_batch, y_batch)
epoch_loss = epoch_loss * 1.0 / (N / BATCH_SIZE)
print '%s,%s,%s,%s' % (
epoch, epoch_loss,
accuracy(model.predict(X_train), from_one_hot(Y_train)),
accuracy(model.predict(X_val), from_one_hot(Y_val))
)
xaxis.append(epoch)
yaxis.append(accuracy(model.predict(X_train), from_one_hot(Y_train)))
plt.plot(xaxis, yaxis)
plt.show()
# TODO - CLEAN THIS SHIT UP
print '=== BASELINE ACC'
Y_val = from_one_hot(Y_val)
N1 = np.sum(Y_val)
N0 = len(Y_val) - N1
print '\t random (freqs): %s' % (max(N0, N1) * 1.0 / (N0 + N1))