В первой части части я перевел обученную модель полносвязной сети на базе Keras на работу с матричными вычислениями. Модель разработана для новостного агрегатора с целью фильтрации нежелательных новостей.
Но если посмотреть статью-руководство от tensorflow, можно увидеть, что одной из рекомендаций по классификации теста является использование сетей долгой краткосрочной памяти (LSTM).
Для моей задачи сеть прямого распространения обладает достаточным качеством, предсказуемостью и стабильностью результатов (объяснимое переобучение, влияние архитектуры сети на качество и т.д.). Ну и немаловажно - быстро обучается, в отличие от LSTM.
Но ради "академического" интереса обучим сеть c LSTM для бинароной классификации текста и переведем её также на работу только с матрицами и пакетом numpy. Это также наглядно покажет, как устроены ячейки LSTM.
Сеть LSTM
Итак, tensorflow рассматривает следующую архитектуру сети:
model = tf.keras.Sequential([
encoder,
tf.keras.layers.Embedding(
input_dim=len(encoder.get_vocabulary()),
output_dim=64,
# Use masking to handle the variable sequence lengths
mask_zero=True),
tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64)),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(1)
])Вот как она выглядит в графическом виде:
(https://www.tensorflow.org/text/tutorials/text_classification_rnn)
Модули TextVectorization и tf.keras.layers.Embeddingте же, что были в первой части моей работы. Вкратце напомню, что TextVectorization преобразует слова в уникальные числовые индексы, а Embedding затем преобразует их в плотные вектора.
Далее идет слой LSTM, который с помощью слоя tf.keras.layers.Bidirectional "проходится" по двум направлениям: от начала последовательности к концу и наоборот, а затем объединяет результаты. Но для начала надо смоделировать более простую архитектуру - без tf.keras.layers.Bidirectional, а зачем уже с ним.
Рассмотрим следующую модель:
model = tf.keras.Sequential([
tf.keras.layers.Embedding(
input_dim=len(encoder.get_vocabulary()),
output_dim=64,
mask_zero=True),
tf.keras.layers.LSTM(64),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(1, activation='sigmoid')
])Для визуального понимания кода модели tf.keras.layers.LSTMрассмотрим типовую схему ячейки LSTM. На ней я подписал все функции, которые мы должны вычислить.
Получить веса обученной модели для этого слоя не так просто как для слоев Dense и Embedding - это делается следующим образом (вот тут про это хорошо написано):
# Количество ячеек памяти. Задается при объявлении слоя tf.keras.layers.LSTM(units)
units = int(int(model.layers[1].trainable_weights[0].shape[1])/4)
print("No units: ", units)
W = model.layers[1].get_weights()[0]
U = model.layers[1].get_weights()[1]
b = model.layers[1].get_weights()[2]
W_i = W[:, :units]
W_f = W[:, units: units * 2]
W_c = W[:, units * 2: units * 3]
W_o = W[:, units * 3:]
U_i = U[:, :units]
U_f = U[:, units: units * 2]
U_c = U[:, units * 2: units * 3]
U_o = U[:, units * 3:]
b_i = b[:units]
b_f = b[units: units * 2]
b_c = b[units * 2: units * 3]
b_o = b[units * 3:]Веса W используются при математических операциях с входной последовательностью x (т.е. выходом слоя Embedding). Веса U - для преобразования состояния h прошлой итерации. b - это смещение (bias).
Символ 
означает операцию np.multiply. Символ 
обычное поэлементное суммирование векторов.
С учетом особенностей работы ячеек LSTM индексы с названиях коэффициентов обозначают "функциональное назначение" элементов:
Индекс "f" — функция забывания/forget gate. По сути, тут с помощью умножения на коэффициент от 0 до 1 управляется значением состояния Сt для удаления информации о прошлых шагах обработки. Код для вычисления:
# letter - это очередной символ из слоя Embedding
# h_st - выход предыдущей ячейки
self.f_t = self.sigmoid(np.dot(letter, self.W_f)
+ np.dot(self.h_st, self.U_f)
+ self.b_f)Индекс "i "— добавление информации к состояния, «входной вентиль». Здесь на основе выхода предыдущей ячейки ht-1 и ввода xt определяется, какие значения использовать из ввода (x) во внутреннем состоянии. Код:
# letter - это очередной символ из слоя Embedding
# h_st - выход предыдущей ячейки
self.i_t = self.sigmoid(np.dot(letter, self.W_i)
+ np.dot(self.h_st, self.U_i)
+ self.b_i)Индекс "с" — подготовка функции Ĉt
self.Ct_t = np.tanh(np.dot(letter, self.W_c)
+ np.dot(self.h_st, self.U_c)
+ self.b_c)Теперь все готово для расчета нового клеточного состояния Сt
self.state = np.multiply(self.f_t, self.state) + np.multiply(self.i_t, self.Ct_t)Индекс "о" - расчет выходного значения. Применяем гиперболический тангенс к текущему состоянию ячейки и умножаем на преобразованное значение текущего входного символа:
self.h_st = np.multiply(self.sigmoid(np.dot(letter, self.W_o)
+ np.dot(self.h_st, self.U_o)
+ self.b_o),
np.tanh(self.state))Полный код ячейки LSTM выглядит следующим образом.
def lstm(self, data):
# инициализация начального состояния ячейки и выходного состояния для работы на первой итерации
self.state=np.zeros(self.units)
self.h_st=np.zeros(self.units)
# проходим по символам в прямом направлении.
for letter in data:
self.f_t = self.sigmoid(np.dot(letter, self.W_f) + np.dot(self.h_st, self.U_f) + self.b_f)
self.i_t = self.sigmoid(np.dot(letter, self.W_i) + np.dot(self.h_st, self.U_i) + self.b_i)
self.Ct_t = np.tanh(np.dot(letter, self.W_c) + np.dot(self.h_st, self.U_c) + self.b_c)
self.state = np.multiply(self.f_t, self.state) + np.multiply(self.i_t, self.Ct_t)
self.h_st = np.multiply(self.sigmoid(np.dot(letter, self.W_o) + np.dot(self.h_st, self.U_o)+ self.b_o), np.tanh(self.state))
return np.array(self.h_st)Bidirectional LSTM
В случае использования tf.keras.layers.Bidirectional создается два слоя LSTM: один проходит цепочку слов в прямом направлении, второй - в обратном. Зачем результаты конкатенируются.
В результате обучения у нас получает две группы весов (для LSTM прямого и обратного направления соответственно) . Веса получают из обученной модели следующим образом:
self.vocal_dict = {vocal_dict[k]: k for k in range(len(vocal_dict))}
self.units = units
# слой прямого прохождения
self.W_farward = lstm_weights[0]
self.U_farward = lstm_weights[1]
self.b_farward = lstm_weights[2]
self.W_i_farward = self.W_farward[:, :self.units]
self.W_f_farward = self.W_farward[:, self.units: self.units * 2]
self.W_c_farward = self.W_farward[:, self.units * 2: self.units * 3]
self.W_o_farward = self.W_farward[:, self.units * 3:]
self.U_i_farward = self.U_farward[:, :self.units]
self.U_f_farward = self.U_farward[:, self.units: self.units * 2]
self.U_c_farward = self.U_farward[:, self.units * 2: self.units * 3]
self.U_o_farward = self.U_farward[:, self.units * 3:]
self.b_i_farward = self.b_farward[:self.units]
self.b_f_farward = self.b_farward[self.units: self.units * 2]
self.b_c_farward = self.b_farward[self.units * 2: self.units * 3]
self.b_o_farward = self.b_farward[self.units * 3:]
# слой обратного прохождения
self.W_backward = lstm_weights[3]
self.U_backward = lstm_weights[4]
self.b_backward = lstm_weights[5]
self.W_i_backward = self.W_backward[:, :self.units]
self.W_f_backward = self.W_backward[:, self.units: self.units * 2]
self.W_c_backward = self.W_backward[:, self.units * 2: self.units * 3]
self.W_o_backward = self.W_backward[:, self.units * 3:]
self.U_i_backward = self.U_backward[:, :self.units]
self.U_f_backward = self.U_backward[:, self.units: self.units * 2]
self.U_c_backward = self.U_backward[:, self.units * 2: self.units * 3]
self.U_o_backward = self.U_backward[:, self.units * 3:]
self.b_i_backward = self.b_backward[:self.units]
self.b_f_backward = self.b_backward[self.units: self.units * 2]
self.b_c_backward = self.b_backward[self.units * 2: self.units * 3]
self.b_o_backward = self.b_backward[self.units * 3:] Реализация tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(units)) таким образом, следующая:
def lstm_farward(self, data):
self.state=np.zeros(self.units)
self.h_st=np.zeros(self.units)
for letter in data:
self.f_t = self.sigmoid(np.dot(letter, self.W_f_farward) + np.dot(self.h_st, self.U_f_farward) + self.b_f_farward )
self.i_t = self.sigmoid(np.dot(letter, self.W_i_farward) + np.dot(self.h_st, self.U_i_farward) + self.b_i_farward )
self.Ct_t = np.tanh( np.dot(letter, self.W_c_farward) + np.dot(self.h_st, self.U_c_farward) + self.b_c_farward )
self.state = np.multiply(self.f_t, self.state) + np.multiply(self.i_t, self.Ct_t)
self.h_st = np.multiply(self.sigmoid(np.dot(letter, self.W_o_farward) + np.dot(self.h_st, self.U_o_farward)+ self.b_o_farward), np.tanh(self.state))
return np.array(self.h_st)
def lstm_backward(self, data):
self.state=np.zeros(self.units)
self.h_st=np.zeros(self.units)
for letter in data[::-1]:
self.f_t = self.sigmoid(np.dot(letter, self.W_f_backward) + np.dot(self.h_st, self.U_f_backward) + self.b_f_backward )
self.i_t = self.sigmoid(np.dot(letter, self.W_i_backward) + np.dot(self.h_st, self.U_i_backward) + self.b_i_backward )
self.Ct_t = np.tanh( np.dot(letter, self.W_c_backward) + np.dot(self.h_st, self.U_c_backward) + self.b_c_backward )
self.state = np.multiply(self.f_t, self.state) + np.multiply(self.i_t, self.Ct_t)
self.h_st = np.multiply(self.sigmoid(np.dot(letter, self.W_o_backward) + np.dot(self.h_st, self.U_o_backward)+ self.b_o_backward), np.tanh(self.state))
return np.array(self.h_st)
emb_out = self.embedding(sentanence)
lstm_out_farward = self.lstm_farward(emb_out)
lstm_out_backward = self.lstm_backward(emb_out)
lstm = np.concatenate((lstm_out_farward, lstm_out_backward))Заключение
В данной статье приведено моделирования слоев tf.keras.layers.Bidirectional и tf.keras.layers.LSTM. Полученные модели могут использоваться для развертывания обученной модели на системах без необходимости установки пакета tensorflow, а также для изучения работы LSTM в образовательных целях.
