def interactive_prompt(model: keras.Sequential, vectorizer: Vectorizer):
def get_input():
user_input = input('Enter seed word(s) [Ctrl-C to quit]: ')
user_input = user_input.lower()
return user_input
def one_hot(index):
res = np.zeros(vectorizer.vocab_size, dtype=np.int64)
res[index] = 1
return res
try:
while True:
probs_arr = []
user_input = get_input()
model.reset_states()
pred_ids = []
for token_id in vectorizer.text_to_vector(user_input):
pred_ids.append(token_id)
probs = feed_token(model, token_id)
pred_id = probs.argmax()
# probs_arr.append(probs)
probs_arr.append(one_hot(pred_id))
pred_ids.append(pred_id)
for t in range(500):
probs = feed_token(model, pred_ids[-1])
# probs_arr.append(probs)
pred_ids.append(probs.argmax())
pred_words = vectorizer.sequences_to_docs([[pred_ids]])
assert len(pred_words) == 1, pred_words
pred_words = pred_words[0]
pred_words = ' '.join([
sent.capitalize()
for sent in vectorizer.sent_tokenize(pred_words)
])
print(pred_words)
# print('<>~' * 15)
# sequences = beam_search_decoder(probs_arr, k=2)
# sequences = [thing[0] for thing in sequences]
# beam_rant = vectorizer.sequences_to_docs([sequences])
# print('beam rant:', beam_rant)
except KeyboardInterrupt:
print('Ok bye.')
def train_model(X, Y, X_test, Y_test, nr_steps):
n_batch = 14000
n_epoch = 1000
n_neurons = 30
# design network
model = Sequential()
model.add(
LSTM(units=n_neurons,
return_sequences=True,
batch_input_shape=(n_batch, X.shape[1], X.shape[2]),
stateful=True))
model.add(Dropout(0.2))
# Adding a second LSTM layer and Dropout layer
model.add(LSTM(units=n_neurons, return_sequences=True))
model.add(Dropout(0.2))
model.add(Dense(1))
optimizer = optimizers.Adam(clipvalue=0.5)
model.compile(loss='mean_squared_error',
optimizer=optimizer,
metrics=['acc'])
for z in range(0, len(X) // 4, n_batch):
xChunk = X[z:z + n_batch]
yChunk = Y[z:z + n_batch]
model.fit(xChunk,
yChunk,
epochs=n_epoch,
batch_size=n_batch,
verbose=1,
shuffle=False)
model.reset_states()
yhat = model.predict(X_test[0:n_batch, :, :],
batch_size=n_batch,
steps=nr_steps)
for i in range(len(Y_test[0:n_batch])):
print("Extected : " + str(Y[i]) + " but actually: " + str(yhat[i][0]))
error = 1
for j in range(len(Y_test[0:n_batch])):
error = error * (abs(Y_test[j] - yhat[j][0]) / yhat[j][0]) * 100
print("error: " + str(error) + "%")
def ramble(model: keras.Sequential, vectorizer: Vectorizer, seed='she'):
current_token = vectorizer.word_to_index[seed]
current_seq = [current_token]
model.reset_states()
model.summary()
probs_arr = []
# for t in range(config.max_seq_len):
for t in range(5):
# Format inputs.
inputs = np.zeros((config.find('batch_size'), 1))
assert inputs.shape[0] == 32, inputs.shape
inputs[0, 0] = current_token
# Forward pass.
probs = model.predict_on_batch(inputs)[0]
probs = probs.squeeze()
probs_arr.append(probs)
assert probs.shape == (vectorizer.vocab_size,
), f'{probs.shape} != {vectorizer.vocab_size}'
# Sample prediction.
current_token = probs.argmax()
current_seq.append(current_token)
text_rant = vectorizer.sequences_to_docs([[current_seq]])
assert len(text_rant) == 1, len(text_rant)
# Some post-processing prettification.
text_rant = util.lmap(str.strip, text_rant[0].split('.'))
util.print_box('Rant', list(text_rant))
sequences = beam_search_decoder(probs_arr, k=3)
sequences = [thing[0] for thing in sequences]
beam_rant = vectorizer.sequences_to_docs([sequences])
print('beam rant:', beam_rant)
model.add(LSTM(4, input_shape=(look_back, 1)))
elif type_ == 'b':
model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))
elif type_ == 'c':
model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True, return_sequences=True))
model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))
else:
model.add(LSTM(4, input_shape=(1, look_back)))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
if type_ == 'b' or type_ == 'c':
for i in range(1):
model.fit(trainX, trainY, epochs=1, batch_size=batch_size, verbose=2, shuffle=False)
model.reset_states()
else:
history = model.fit(trainX,
trainY,
epochs = epochs,
batch_size = 1,
verbose = 2)
# Make predictions
if type_ == 'b' or type_ == 'c':
trainPredict = model.predict(trainX, batch_size=batch_size)
testPredict = model.predict(testX, batch_size=batch_size)
else:
trainPredict = model.predict(trainX)
testPredict = model.predict(testX)
