import tensorflow.keras.layers as layers
print(X_test[0].shape)
input = layers.Input(shape=(140, ))
model = Embedding(input_dim=n_words, output_dim=140, input_length=140)(input)
model = Dropout(0.1)(model)
model = Bidirectional(
LSTM(units=100, return_sequences=True, recurrent_dropout=0.1))(model)
out = TimeDistributed(Dense(n_tags, activation="softmax"))(
model) # softmax output layer
model = Model(input, out)
model.compile(optimizer="adam",
loss="categorical_crossentropy",
metrics=["accuracy"])
#p = model.predict(np.array([X_test[0]]))
history = model.fit(X_train,
np.array(y_train),
batch_size=32,
epochs=1,
validation_split=0.2,
verbose=1)
i = 0
p = model.predict(np.array([new_sent]))
p = np.argmax(p, axis=-1)
print("{:14} ({:5}): {}".format("Word", "True", "Pred"))
for w, pred in zip(new_sent, p[0]):
print("{:14}: {}".format(words[w], tags[pred]))
# https://www.kaggle.com/navya098/bi-lstm-for-ner
def fit_predict(self, testIds):
print("START PREPROCESSING")
vocabs = PreProcessor.getVocabs(self.data)
train_data = dict()
test_data = dict()
for k, v in self.data.items():
if k in testIds:
test_data[k] = v
else:
train_data[k] = v
train_data = PreProcessor.preprocess(train_data, self.extraction_of)
test_data = PreProcessor.preprocess(test_data, self.extraction_of)
words = list(set(vocabs))
words.append("ENDPAD")
n_words = len(words)
tags = ['O', self.extraction_of]
n_tags = len(tags)
word2idx = {w: i for i, w in enumerate(words)}
tag2idx = {t: i for i, t in enumerate(tags)}
getter_train = SentenceGetter(train_data)
sentences_train = getter_train.sentences
getter_test = SentenceGetter(test_data)
sentences_test = getter_test.sentences
X_train = [[word2idx[w[0]] for w in s] for s in sentences_train]
X_train = pad_sequences(maxlen=140,
sequences=X_train,
padding="post",
value=n_words - 1)
X_test = [[word2idx[w[0]] for w in s] for s in sentences_test]
X_test = pad_sequences(maxlen=140,
sequences=X_test,
padding="post",
value=n_words - 1)
y_train = [[tag2idx[w[1]] for w in s] for s in sentences_train]
y_train = pad_sequences(maxlen=140,
sequences=y_train,
padding="post",
value=tag2idx["O"])
y_train = [to_categorical(i, num_classes=n_tags) for i in y_train]
y_test = [[tag2idx[w[1]] for w in s] for s in sentences_test]
y_test = pad_sequences(maxlen=140,
sequences=y_test,
padding="post",
value=tag2idx["O"])
y_test = [to_categorical(i, num_classes=n_tags) for i in y_test]
input = Input(shape=(140, ))
model = Embedding(input_dim=n_words, output_dim=50,
input_length=140)(input)
model = Dropout(0.1)(model)
model = Bidirectional(
LSTM(units=100, return_sequences=True,
recurrent_dropout=0.1))(model)
out = TimeDistributed(Dense(n_tags, activation="softmax"))(model)
model = Model(input, out)
model.compile(optimizer="adam",
loss="categorical_crossentropy",
metrics=["accuracy"])
history = model.fit(X_train,
np.array(y_train),
batch_size=32,
epochs=3,
validation_split=0.2,
verbose=1)
y_true = []
y_pred = []
for i in tqdm(range(0, len(X_test))):
p = model.predict(np.array(X_test[i]))
p = np.argmax(p, axis=-1)
t = y_test[i]
for wordIdx, trueTagIdx, predTagIdx in zip(X_test[i], t, p[0]):
tag_true = tags[np.argmax(trueTagIdx, axis=-1)]
tag_pred = tags[predTagIdx]
y_true.append(tag_true)
y_pred.append(tag_pred)
return y_true, y_pred
# In[34]:
model.save('./')
# In[77]:
model.evaluate(X_test, Y_test)
# In[124]:
# Preprocessing User Input
def word_to_idx(words_predict):
words_idx = np.full((max_len, ), len(words) - 1)
i = 0
for w in words_predict:
words_idx[i] = wordtoidx[w]
i += 1
return words_idx
input_sentence = "I want to fly in an Airbus. I am planning a trip to London"
words_predict = list(set(word_tokenize(input_sentence)))
x_predict = word_to_idx(words_predict)
p = model.predict(np.array(x_predict))
p = np.argmax(p, axis=-1)
for i in range(len(p)):
print("{} - {}".format(words[x_predict[i]], tags[p[i][0]]))
# In[ ]:
metrics=["accuracy"])
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
from livelossplot.tf_keras import PlotLossesCallback
# chkpt = ModelCheckpoint("model_weights.h5", monitor='val_loss',verbose=1, save_best_only=True, save_weights_only=True, mode='min')
#
# early_stopping = EarlyStopping(monitor='val_accuracy', min_delta=0, patience=1, verbose=0, mode='max', baseline=None, restore_best_weights=False)
#
# callbacks = [PlotLossesCallback(), chkpt, early_stopping]
#
# history = model.fit(
# x=x_train,
# y=y_train,
# validation_data=(x_test,y_test),
# batch_size=32,
# epochs=3,
# callbacks=callbacks,
# verbose=1
# )
model.evaluate(x_test, y_test)
i = np.random.randint(0, x_test.shape[0]) #659
p = model.predict(np.array([x_test[i]]))
p = np.argmax(p, axis=-1)
y_true = y_test[i]
print("{:15}{:5}\t {}\n".format("Word", "True", "Pred"))
print("-" * 30)
for w, true, pred in zip(x_test[i], y_true, p[0]):
print("{:15}{}\t{}".format(words[w - 1], tags[true], tags[pred]))
LSTM(units=100, return_sequences=True, recurrent_dropout=0.1))(model)
out = TimeDistributed(Dense(n_tags, activation="softmax"))(
model) # softmax output layer
model = Model(input, out)
model.compile(optimizer="adam",
loss="categorical_crossentropy",
metrics=["accuracy"])
# In[28]:
history = model.fit(train_padded_docs,
np.array(y_train),
epochs=1,
verbose=1,
batch_size=32,
validation_data=(padded_val_doc, np.array(y_val)))
# In[30]:
label_list = list(set(data["tag"].values))
[label_list[np.argmax(i)] for i in model.predict(padded_test_doc[5])]
# In[53]:
i = 5
p = [label_list[np.argmax(i)] for i in model.predict(padded_test_doc[i])]
p_real = [label_list[np.argmax(x)] for x in y_test[i]]
print("{:14}:{:5}:{}".format("Word", "True", "Pred"))
for w, y, pred in zip(X_test[i], p_real, p):
print("{:14}:{:5}:{}".format(w, y, pred))