Python для НЛП: Встраивание слов для глубокого обучения в Keras
Это 16-я статья в моей серии статей по Python для НЛП. В своей предыдущей статье я объяснил, как метод N-граммов может быть использован для разработки простого автоматического текстового наполнителя в Python. N-Граммовая модель-это в основном способ преобразования текстовых данных в числовую форму, чтобы их можно было использовать статистическими алгоритмами.
Перед N-граммами я объяснил подход bag of words и TF-IDF, которые также могут быть использованы для генерации числовых векторов признаков из текстовых данных. До сих пор мы использовали подходы машинного обучения для выполнения различных задач НЛП, таких как классификация текста, тематическое моделирование, сентиментальный анализ, обобщение текста и т. Д. В этой статье мы начнем наше обсуждение методов глубокого обучения для НЛП.
Подходы к глубокому обучению состоят из различных типов плотно связанных нейронных сетей. Эти подходы доказали свою эффективность для решения ряда сложных задач, таких как самоуправляемые автомобили, генерация изображений, сегментация изображений и т. Д. Подходы глубокого обучения также доказали свою эффективность для задач НЛП.
В этой статье мы рассмотрим встраивание слов для задач НЛП, которые включают глубокое обучение. Мы увидим, как вложения слов могут быть использованы для выполнения простой задачи классификации с помощью глубокой нейронной сети в библиотеке Python Keras .
Проблемы с подходами к вектору признаков с одним горячим кодированием
Потенциальный недостаток подходов с одним горячим кодированием вектора признаков, таких как N-граммы, мешок слов и подход TF-IDF, заключается в том, что вектор признаков для каждого документа может быть огромным. Например, если у вас есть полмиллиона уникальных слов в вашем корпусе и вы хотите представить предложение, содержащее 10 слов, ваш вектор признаков будет полумиллионным одномерным вектором с горячей кодировкой, где только 10 индексов будут иметь 1. Это пустая трата пространства и экспоненциально увеличивает сложность алгоритма, что приводит к проклятию размерности .
Встраивание слов
В вложениях слов каждое слово представляется в виде n-мерного плотного вектора. Слова, которые похожи, будут иметь одинаковый вектор. Методы встраивания слов, такие как GloVe и Word2Vec , оказались чрезвычайно эффективными для преобразования слов в соответствующие плотные векторы. Размер вектора невелик, и ни один из индексов в векторе на самом деле не пуст.
Реализация вложений слов с помощью последовательных моделей Keras
Библиотека Keras-одна из самых известных и часто используемых библиотек глубокого обучения для Python, построенная поверх TensorFlow .
Keras поддерживает два типа API: последовательный и функциональный. В этом разделе мы увидим, как встраивание слов используется с последовательным API Keras. В следующем разделе я объясню, как реализовать ту же модель с помощью функционального API Keras.
Для реализации вложений слов библиотека Keras содержит слой с именем Embedding() . Слой встраивания реализован в виде класса в Керале и обычно используется в качестве первого слоя в последовательной модели для задач НЛП.
Слой встраивания может быть использован для выполнения трех задач в Keras:
- Он может быть использован для изучения вложений слов и сохранения полученной модели
- Он может быть использован для изучения вложений слов в дополнение к выполнению задач НЛП, таких как классификация текста, анализ настроений и т. Д.
- Он может быть использован для загрузки предварительно обученных вложений слов и использования их в новой модели
В этой статье мы рассмотрим второй и третий варианты использования слоя встраивания. Первый вариант использования является подмножеством второго варианта использования.
Давайте посмотрим, как выглядит слой встраивания:
embedding_layer = Embedding(200, 32, input_length=50)
Первый параметр в слое встраивания-это размер словаря или общее количество уникальных слов в корпусе. Второй параметр – это число измерений для каждого вектора слов. Например, если вы хотите, чтобы каждый вектор слов имел 32 измерения, вы укажете 32 в качестве второго параметра. И, наконец, третий параметр-длина входного предложения.
Результатом встраивания слов является двумерный вектор, в котором слова представлены строками, а соответствующие им размеры-столбцами. Наконец, если вы хотите напрямую соединить свой слой встраивания слов с плотно связанным слоем, вам сначала нужно сгладить свои 2D-встраивания слов в 1D. Эти понятия станут более понятными, как только мы увидим, как слово внедряется в действие.
Пользовательские Вложения Слов
Как я уже говорил ранее, Keras можно использовать либо для изучения пользовательских вложений слов, либо для загрузки предварительно обученных вложений слов. В этом разделе мы увидим, как слой встраивания Keras можно использовать для изучения пользовательских встраиваний слов.
Мы будем выполнять простые задачи классификации текста, которые будут использовать вложения слов. Выполните следующий сценарий для загрузки необходимых библиотек:
from numpy import array from keras.preprocessing.text import one_hot from keras.preprocessing.sequence import pad_sequences from keras.models import Sequential from keras.layers import Dense from keras.layers import Flatten from keras.layers.embeddings import Embedding
Далее нам нужно определить наш набор данных. Мы будем использовать очень простой пользовательский набор данных, который будет содержать обзоры выше фильмов. Следующий скрипт создает наш набор данных:
corpus = [
# Positive Reviews
'This is an excellent movie',
'The move was fantastic I like it',
'You should watch it is brilliant',
'Exceptionally good',
'Wonderfully directed and executed I like it',
'Its a fantastic series',
'Never watched such a brillent movie',
'It is a Wonderful movie',
# Negtive Reviews
"horrible acting",
'waste of money',
'pathetic picture',
'It was very boring',
'I did not like the movie',
'The movie was horrible',
'I will not recommend',
'The acting is pathetic'
]
Наш корпус имеет 8 положительных и 8 отрицательных отзывов. Следующий шаг-создание набора меток для наших данных.
sentiments = array([1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0])
Вы можете видеть, что первые 8 элементов в массиве настроений содержат 1, что соответствует положительному настроению. Последние 8 пунктов равны нулю, что соответствует негативным настроениям.
Ранее мы говорили, что первым параметром слоя Embedding() является словарь, или количество уникальных слов в корпусе. Давайте сначала найдем общее количество слов в нашем корпусе:
from nltk.tokenize import word_tokenize
all_words = []
for sent in corpus:
tokenize_word = word_tokenize(sent)
for word in tokenize_word:
all_words.append(word)
В приведенном выше сценарии мы просто повторяем каждое предложение в нашем корпусе, а затем маркируем предложение словами. Далее мы перебираем список всех слов и добавляем их в список all_words . После выполнения описанного выше сценария вы должны увидеть все слова в словаре all_words . Однако нам не нужны повторяющиеся слова.
Мы можем получить все уникальные слова из списка, передав список в функцию set , как показано ниже.
unique_words = set(all_words) print(len(unique_words))
В выводе вы увидите “45”, то есть количество уникальных слов в нашем корпусе. Мы добавим буфер размером 5 к размеру нашего словаря и установим значение vocab_length равным 50.
Слой встраивания ожидает, что слова будут иметь числовую форму. Поэтому нам нужно преобразовать предложения в нашем корпусе в числа. Одним из способов преобразования текста в числа является использование функции one_hot из библиотеки keras.preprocessing.text . Функция принимает предложение и общую длину словаря и возвращает предложение в числовой форме.
embedded_sentences = [one_hot(sent, vocab_length) for sent in corpus] print(embedded_sentences )
В приведенном выше сценарии мы преобразуем все предложения в нашем корпусе в числовую форму и выводим их на консоль. Вывод выглядит следующим образом:
[[31, 12, 31, 14, 9], [20, 3, 20, 16, 18, 45, 14], [16, 26, 29, 14, 12, 1], [16, 23], [32, 41, 13, 20, 18, 45, 14], [15, 28, 16, 43], [7, 9, 31, 28, 31, 9], [14, 12, 28, 46, 9], [4, 22], [5, 4, 9], [23, 46], [14, 20, 32, 14], [18, 1, 26, 45, 20, 9], [20, 9, 20, 4], [18, 8, 26, 34], [20, 22, 12, 23]]
Вы можете видеть, что наше первое предложение содержало пять слов, поэтому у нас есть пять целых чисел в первом элементе списка. Кроме того, обратите внимание, что последнее слово первого предложения было “фильм” в первом элементе списка, и у нас есть цифра 9 на пятом месте полученного 2D-массива, что означает, что “фильм” был закодирован как 9 и так далее.
Слой встраивания ожидает, что предложения будут одинакового размера. Однако наши закодированные предложения имеют разный размер. Один из способов сделать все предложения одинакового размера-увеличить длину всех предложений и сделать ее равной длине самого большого предложения. Давайте сначала найдем самое большое предложение в нашем корпусе, а затем увеличим длину всех предложений до длины самого большого предложения. Для этого выполните следующий сценарий:
word_count = lambda sentence: len(word_tokenize(sentence)) longest_sentence = max(corpus, key=word_count) length_long_sentence = len(word_tokenize(longest_sentence))
В приведенном выше предложении мы используем лямбда-выражение , чтобы найти длину всех предложений. Затем мы используем функцию max для возврата самого длинного предложения. Наконец, самое длинное предложение маркируется в слова, и количество слов подсчитывается с помощью функции len .
Далее, чтобы сделать все предложения одинакового размера, мы добавим нули к пустым индексам, которые будут созданы в результате увеличения длины предложения. Чтобы добавить нули в конце предложений, мы можем использовать метод pad_sequences . Первый параметр-это список закодированных предложений неравных размеров, второй параметр-размер самого длинного предложения или индекс заполнения, а последний параметр – padding , где вы указываете post для добавления заполнения в конце предложений.
Выполните следующий сценарий:
padded_sentences = pad_sequences(embedded_sentences, length_long_sentence, padding='post') print(padded_sentences)
В выходных данных вы должны увидеть предложения с отступами.
[[31 12 31 14 9 0 0] [20 3 20 16 18 45 14] [16 26 29 14 12 1 0] [16 23 0 0 0 0 0] [32 41 13 20 18 45 14] [15 28 16 43 0 0 0] [ 7 9 31 28 31 9 0] [14 12 28 46 9 0 0] [ 4 22 0 0 0 0 0] [ 5 4 9 0 0 0 0] [23 46 0 0 0 0 0] [14 20 32 14 0 0 0] [18 1 26 45 20 9 0] [20 9 20 4 0 0 0] [18 8 26 34 0 0 0] [20 22 12 23 0 0 0]]
Вы можете видеть нули в конце предложений с подкладкой.
Теперь у нас есть все необходимое для создания модели классификации настроений с использованием вложений слов.
Мы создадим очень простую модель классификации текста с вложенным слоем и без скрытых слоев. Посмотрите на следующий сценарий:
model = Sequential() model.add(Embedding(vocab_length, 20, input_length=length_long_sentence)) model.add(Flatten()) model.add(Dense(1, activation='sigmoid'))
В приведенном выше скрипте мы создаем Последовательную модель и добавляем слой Embedding в качестве первого слоя к модели. Длина словаря задается параметром vocab_length . Размерность каждого вектора слов будет равна 20, а input_length будет длиной самого длинного предложения, которое равно 7. Далее слой Embedding выравнивается так, чтобы его можно было непосредственно использовать с плотно связанным слоем. Поскольку это проблема бинарной классификации, мы используем функцию sigmoid в качестве функции потерь в плотном слое.
Далее мы скомпилируем модель и распечатаем краткое описание нашей модели, как показано ниже:
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc']) print(model.summary())
Краткое описание модели выглядит следующим образом:
Layer (type) Output Shape Param # ================================================================= embedding_1 (Embedding) (None, 7, 20) 1000 _________________________________________________________________ flatten_1 (Flatten) (None, 140) 0 _________________________________________________________________ dense_1 (Dense) (None, 1) 141 ================================================================= Total params: 1,141 Trainable params: 1,141 Non-trainable params: 0
Вы можете видеть, что первый слой имеет 1000 обучаемых параметров. Это связано с тем, что наш словарный запас составляет 50 единиц, и каждое слово будет представлено в виде 20-мерного вектора. Следовательно, общее число обучаемых параметров будет равно 1000. Аналогично, выход из слоя вложения будет представлять собой предложение из 7 слов, где каждое слово представлено 20-мерным вектором. Однако, когда 2D-выход сглажен, мы получаем 140-мерный вектор (7 x 20). Уплощенный вектор непосредственно связан с плотным слоем, содержащим 1 нейрон.
Теперь давайте обучим модель на наших данных с помощью метода fit , как показано ниже:
model.fit(padded_sentences, sentiments, epochs=100, verbose=1)
Модель будет обучаться в течение 100 эпох.
Мы будем тренировать и тестировать модель, используя тот же корпус. Выполните следующий сценарий для оценки производительности модели в нашем корпусе:
loss, accuracy = model.evaluate(padded_sentences, sentiments, verbose=0)
print('Accuracy: %f' % (accuracy*100))
На выходе вы увидите, что точность модели составляет 1,00, то есть 100 процентов.
Примечание : В реальных приложениях обучающие и тестовые наборы должны быть разными. Мы увидим пример этого, когда будем выполнять классификацию текста на некоторых реальных данных в следующей статье.
Загрузка Предварительно Подготовленных Вложений Слов
В предыдущем разделе мы обучали пользовательским вложениям слов. Однако мы также можем использовать предварительно подготовленные вложения слов.
Существует несколько типов предварительно подготовленных встраиваний слов, однако мы будем использовать встраивания слов перчаток из Стэнфордского НЛП, поскольку это наиболее известный и часто используемый метод. Встраивание слов можно скачать по ссылке this link .
Самый маленький файл называется “Glove.6B.zip”. Размер файла-822 МБ. Файл содержит 50, 100, 200 и 300 размерных векторов слов для 400 тысяч слов. Мы будем использовать 100-мерный вектор.
Процесс очень похож. Сначала мы должны импортировать необходимые библиотеки:
from numpy import array from keras.preprocessing.text import one_hot from keras.preprocessing.sequence import pad_sequences from keras.models import Sequential from keras.layers import Dense from keras.layers import Flatten from keras.layers.embeddings import Embedding
Затем мы должны создать наш корпус, за которым следуют метки.
corpus = [
# Positive Reviews
'This is an excellent movie',
'The move was fantastic I like it',
'You should watch it is brilliant',
'Exceptionally good',
'Wonderfully directed and executed I like it',
'Its a fantastic series',
'Never watched such a brillent movie',
'It is a Wonderful movie',
# Negtive Reviews
"horrible acting",
'waste of money',
'pathetic picture',
'It was very boring',
'I did not like the movie',
'The movie was horrible',
'I will not recommend',
'The acting is pathetic'
]
sentiments = array([1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0])
В последнем разделе мы использовали функцию one_hot для преобразования текста в векторы. Другой подход заключается в использовании функции Tokenizer из библиотеки keras.preprocessing.text .
Вам просто нужно передать свой корпус в метод Tokenizer ‘s fit_on_text .
word_tokenizer = Tokenizer() word_tokenizer.fit_on_texts(corpus)
Чтобы получить количество уникальных слов в тексте, вы можете просто подсчитать длину word_index словаря объекта word_tokenizer . Не забудьте добавить 1 к размеру словаря. Это делается для хранения измерений для слов, для которых не существует предварительно подготовленных вложений слов.
vocab_length = len(word_tokenizer.word_index) + 1
Наконец, чтобы преобразовать предложения в их числовой аналог, вызовите функцию texts_to_sequences и передайте ей весь корпус.
embedded_sentences = word_tokenizer.texts_to_sequences(corpus) print(embedded_sentences)
В выходных данных вы увидите предложения в их числовой форме:
[[14, 3, 15, 16, 1], [4, 17, 6, 9, 5, 7, 2], [18, 19, 20, 2, 3, 21], [22, 23], [24, 25, 26, 27, 5, 7, 2], [28, 8, 9, 29], [30, 31, 32, 8, 33, 1], [2, 3, 8, 34, 1], [10, 11], [35, 36, 37], [12, 38], [2, 6, 39, 40], [5, 41, 13, 7, 4, 1], [4, 1, 6, 10], [5, 42, 13, 43], [4, 11, 3, 12]]
Следующий шаг состоит в том, чтобы найти количество слов в самом длинном предложении, а затем применить отступы к предложениям, имеющим меньшую длину, чем длина самого длинного предложения.
from nltk.tokenize import word_tokenize word_count = lambda sentence: len(word_tokenize(sentence)) longest_sentence = max(corpus, key=word_count) length_long_sentence = len(word_tokenize(longest_sentence)) padded_sentences = pad_sequences(embedded_sentences, length_long_sentence, padding='post') print(padded_sentences)
Мягкие предложения выглядят так:
[[14 3 15 16 1 0 0] [ 4 17 6 9 5 7 2] [18 19 20 2 3 21 0] [22 23 0 0 0 0 0] [24 25 26 27 5 7 2] [28 8 9 29 0 0 0] [30 31 32 8 33 1 0] [ 2 3 8 34 1 0 0] [10 11 0 0 0 0 0] [35 36 37 0 0 0 0] [12 38 0 0 0 0 0] [ 2 6 39 40 0 0 0] [ 5 41 13 7 4 1 0] [ 4 1 6 10 0 0 0] [ 5 42 13 43 0 0 0] [ 4 11 3 12 0 0 0]]
Мы превратили наши предложения в дополненную последовательность чисел. Следующим шагом является загрузка вложений слов перчаток, а затем создание нашей матрицы вложений, содержащей слова в нашем корпусе и соответствующие им значения из вложений перчаток. Запустите следующий скрипт:
from numpy import array
from numpy import asarray
from numpy import zeros
embeddings_dictionary = dict()
glove_file = open('E:/Datasets/Word Embeddings/glove.6B.100d.txt', encoding="utf8")
В приведенном выше сценарии, помимо загрузки вложений перчаток, мы также импортировали несколько библиотек. Использование этих библиотек мы увидим в следующем разделе. Здесь обратите внимание, что мы загрузили glove.6B.100d.txt файл. Этот файл содержит 100 размерных вложений слов. Мы также создали пустой словарь, в котором будут храниться наши вложения слов.
Если вы откроете файл, то увидите слово в начале каждой строки, за которым следует набор из 100 чисел. Числа из 100-мерного вектора для слова в начале каждой строки.
Мы создадим словарь, который будет содержать слова в виде ключей и соответствующие 100 мерных векторов в виде значений, в виде массива. Выполните следующий сценарий:
for line in glove_file:
records = line.split()
word = records[0]
vector_dimensions = asarray(records[1:], dtype='float32')
embeddings_dictionary [word] = vector_dimensions
glove_file.close()
Словарь embeddings_dictionary теперь содержит слова и соответствующие им вложения перчаток для всех слов.
Нам нужны вложения слов только для тех слов, которые присутствуют в нашем корпусе. Мы создадим двумерный массив numpy из 44 строк (размер словаря) и 100 столбцов. Массив изначально будет содержать нули. Массив будет называться как embedding_matrix
Далее мы будем перебирать каждое слово в нашем корпусе, проходя через словарь word_tokenizer.word_index , содержащий наши слова и соответствующий им индекс.
Каждое слово будет передано в качестве ключа в embedding_dictionary для получения соответствующего 100-мерного вектора для этого слова. Затем 100-мерный вектор будет сохранен в соответствующем индексе слова в embedding_matrix . Посмотрите на следующий сценарий:
embedding_matrix = zeros((vocab_length, 100))
for word, index in word_tokenizer.word_index.items():
embedding_vector = embeddings_dictionary.get(word)
if embedding_vector is not None:
embedding_matrix[index] = embedding_vector
Наша embedding_matrix теперь содержит предварительно подготовленные вложения слов для слов в нашем корпусе.
Теперь мы готовы создать нашу последовательную модель. Посмотрите на следующий сценарий:
model = Sequential() embedding_layer = Embedding(vocab_length, 100, weights=[embedding_matrix], input_length=length_long_sentence, trainable=False) model.add(embedding_layer) model.add(Flatten()) model.add(Dense(1, activation='sigmoid'))
Сценарий остается прежним, за исключением слоя встраивания. Здесь, в слое встраивания, первым параметром является размер словаря. Второй параметр – это векторная размерность выходного вектора. Поскольку мы используем предварительно подготовленные вложения слов, содержащие 100-мерный вектор, мы устанавливаем размерность вектора равным 100.
Еще один очень важный атрибут слоя Embedding () , который мы не использовали в предыдущем разделе, – это weights . Вы можете передать свою предварительно обученную матрицу встраивания в качестве весов по умолчанию параметру weights . И поскольку мы не обучаем слой встраивания, атрибут trainable был установлен в False .
Давайте скомпилируем нашу модель и посмотрим краткое описание нашей модели:
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc']) print(model.summary())
Мы снова используем adam в качестве оптимизатора, чтобы минимизировать потери. Используемая функция потерь-это binary_cross entropy . И мы хотим видеть результаты в виде точности, поэтому acc был передан в качестве значения для атрибута metrics .
Краткое описание модели выглядит следующим образом:
Layer (type) Output Shape Param # ================================================================= embedding_1 (Embedding) (None, 7, 100) 4400 _________________________________________________________________ flatten_1 (Flatten) (None, 700) 0 _________________________________________________________________ dense_1 (Dense) (None, 1) 701 ================================================================= Total params: 5,101 Trainable params: 701 Non-trainable params: 4,400 _________________________________________________________________
Вы можете видеть, что поскольку в нашем словаре 44 слова и каждое слово будет представлено в виде 100-мерного вектора, то число параметров для слоя встраивания будет 44 x . Выход из слоя встраивания будет представлять собой 2D-вектор с 7 строками (по 1 для каждого слова в предложении) и 100 столбцами. Выход из слоя встраивания будет сглажен так, чтобы его можно было использовать с плотным слоем. Наконец, плотный слой используется для предсказания.
Выполните следующий сценарий для обучения алгоритмов:
model.fit(padded_sentences, sentiments, epochs=100, verbose=1)
После того, как алгоритм обучен, запустите следующий сценарий для оценки производительности алгоритма.
loss, accuracy = model.evaluate(padded_sentences, sentiments, verbose=0)
print('Accuracy: %f' % (accuracy*100))
На выходе вы должны увидеть, что точность составляет 1.000, то есть 100%.
Встраивание слов с помощью функционального API Keras
В последнем разделе мы видели, как встраивание слов может использоваться с последовательным API Keras. Хотя последовательный API является хорошей отправной точкой для начинающих, поскольку он позволяет быстро создавать модели глубокого обучения, чрезвычайно важно знать, как работает функциональный API Keras. Большинство продвинутых моделей глубокого обучения, включающих несколько входов и выходов, используют функциональный API.
В этом разделе мы увидим, как мы можем реализовать слой встраивания с помощью функционального API Keras.
Остальная часть сценария остается такой же, как и в предыдущем разделе. Единственное изменение будет заключаться в разработке модели глубокого обучения. Давайте реализуем ту же модель глубокого обучения, что и в предыдущем разделе, с помощью Keras Functional API.
from keras.models import Model from keras.layers import Input deep_inputs = Input(shape=(length_long_sentence,)) embedding = Embedding(vocab_length, 100, weights=[embedding_matrix], input_length=length_long_sentence, trainable=False)(deep_inputs) # line A flatten = Flatten()(embedding) hidden = Dense(1, activation='sigmoid')(flatten) model = Model(inputs=deep_inputs, outputs=hidden)
В функциональном API Keras вы должны определить входной слой отдельно перед слоем встраивания. Во входном слое вам нужно просто передать длину входного вектора. Чтобы указать этот предыдущий слой в качестве входных данных для следующего слоя, предыдущий слой передается в качестве параметра внутри круглой скобки в конце следующего слоя.
Например, в приведенном выше скрипте вы можете видеть, что deep_inputs передается в качестве параметра в конце слоя встраивания. Аналогично, embedding передается в качестве входных данных в конце слоя Flatten() и так далее.
Наконец, в Model () вы должны передать входной слой и конечный выходной слой.
Теперь давайте скомпилируем модель и взглянем на краткое описание модели.
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc']) print(model.summary())
Вывод выглядит следующим образом:
Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) (None, 7) 0 _________________________________________________________________ embedding_1 (Embedding) (None, 7, 100) 4400 _________________________________________________________________ flatten_1 (Flatten) (None, 700) 0 _________________________________________________________________ dense_1 (Dense) (None, 1) 701 ================================================================= Total params: 5,101 Trainable params: 701 Non-trainable params: 4,400
В сводке модели вы можете увидеть входной слой как отдельный слой перед слоем встраивания. В остальном модель остается прежней.
Наконец, процесс подгонки и оценки модели такой же, как и в последовательном API:
model.fit(padded_sentences, sentiments, epochs=100, verbose=1)
loss, accuracy = model.evaluate(padded_sentences, sentiments, verbose=0)
print('Accuracy: %f' % (accuracy*100))
В выводе вы увидите точность 1.000, то есть 100 процентов.
Вывод
Чтобы использовать текстовые данные в качестве входных данных для модели глубокого обучения, нам нужно преобразовать текст в числа. Однако, в отличие от моделей машинного обучения, передача разреженного вектора огромных размеров может сильно повлиять на модели глубокого обучения. Поэтому нам нужно преобразовать наш текст в небольшие плотные векторы. Встраивание слов помогает нам преобразовывать текст в плотные векторы.
В этой статье мы увидели, как встраивание слов может быть реализовано с помощью библиотеки глубокого обучения Keras. Мы реализовали пользовательские встраивания слов, а также использовали предварительно обученные встраивания слов для решения простой задачи классификации. Наконец, мы также увидели, как реализовать встраивание слов с помощью функционального API Keras.