Это 16-я статья из моей серии статей о Python для НЛП. В моей предыдущей статье я объяснил, как можно использовать технику N-граммов для разработки простого автоматического наполнителя текста на Python. Модель N-Gram - это, по сути, способ преобразования текстовых данных в числовую форму для использования статистическими алгоритмами.

Перед N-Grams я объяснил набор слов и подходы TF-IDF , которые также можно использовать для генерации числовых векторов признаков из текстовых данных. До сих пор мы использовали программы машинного обучения для выполнения различных задач НЛП, таких как классификация текста, моделирование тем, сентиментальный анализ, обобщение текста и т. Д. В этой статье мы начнем обсуждение методов глубокого обучения для НЛП.

Подходы глубокого обучения состоят из различных типов плотно связанных нейронных сетей. Эти подходы доказали свою эффективность для решения нескольких сложных задач, таких как беспилотные автомобили, генерация изображений, сегментация изображений и т. Д. Подходы глубокого обучения также оказались достаточно эффективными для задач НЛП.

В этой статье мы изучим вложения слов для задач НЛП, требующих глубокого обучения. Мы увидим, как вложения слов можно использовать для выполнения простой задачи классификации с использованием глубокой нейронной сети в библиотеке Python Keras.

Проблемы с подходами с одним горячим кодированием векторов признаков

Потенциальный недостаток подходов с одним горячим кодированием вектора признаков, таких как N-граммы, набор слов и подход TF-IDF, заключается в том, что вектор признаков для каждого документа может быть огромным. Например, если у вас есть полмиллиона уникальных слов в вашем корпусе, и вы хотите представить предложение, содержащее 10 слов, ваш вектор признаков будет полумиллионным размерным вектором с горячим кодированием, где только 10 индексов будут иметь 1. Это трата места и экспоненциально увеличивает сложность алгоритма, что приводит к проклятию размерности .

Вложения слов

При встраивании слов каждое слово представляется как n-мерный плотный вектор. Похожие слова будут иметь похожий вектор. Методы встраивания слов, такие как GloVe и Word2Vec , оказались чрезвычайно эффективными для преобразования слов в соответствующие плотные векторы. Размер вектора невелик, и ни один из индексов в векторе на самом деле не пуст.

Реализация встраивания слов с последовательными моделями Keras

Библиотека Keras - одна из самых известных и часто используемых библиотек глубокого обучения для Python, построенная на основе TensorFlow .

Keras поддерживает два типа API: последовательный и функциональный. В этом разделе мы увидим, как вложения слов используются с Keras Sequential API. В следующем разделе я объясню, как реализовать ту же модель с помощью функционального API Keras.

Для реализации встраивания слов библиотека Keras содержит слой под названием Embedding() . Уровень внедрения реализован в форме класса в Keras и обычно используется в качестве первого уровня в последовательной модели для задач НЛП.

Слой внедрения можно использовать для выполнения трех задач в Keras:

• Его можно использовать для изучения встраивания слов и сохранения полученной модели.
• Его можно использовать для изучения вложения слов в дополнение к выполнению задач НЛП, таких как классификация текста, анализ тональности и т. Д.
• Его можно использовать для загрузки предварительно обученных встраиваний слов и использования их в новой модели.

В этой статье мы рассмотрим второй и третий варианты использования слоя Embedding. Первый вариант использования - это подмножество второго варианта использования.

Посмотрим, как выглядит слой встраивания:

 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')) 

В приведенном выше сценарии мы создаем Sequential и добавляем 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 процентов.

Примечание . В реальных приложениях наборы для обучения и тестирования должны отличаться. Мы увидим пример этого, когда выполним классификацию текста на некоторых реальных данных в следующей статье.

Загрузка предварительно обученных вложений слов

В предыдущем разделе мы обучили пользовательские вложения слов. Однако мы также можем использовать предварительно обученные вложения слов.

Существует несколько типов предварительно обученных встраиваний слов, однако мы будем использовать вложения слов GloVe из Стэнфордского НЛП, поскольку это самый известный и часто используемый. Слово вложения можно скачать по этой ссылке .

Самый маленький файл называется «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]] 

Мы преобразовали наши предложения в последовательность чисел с дополнениями. Следующий шаг - загрузить вложения слов GloVe, а затем создать нашу матрицу встраивания, которая содержит слова в нашем корпусе и соответствующие им значения из вложений GloVe. Запустите следующий скрипт:

 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, мы также импортировали несколько библиотек. Мы увидим использование этих библиотек в следующем разделе. glove.6B.100d.txt внимание, что мы загрузили файл 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 теперь содержит слова и соответствующие вложения GloVe для всех слов.

Нам нужны вложения слов только для тех слов, которые присутствуют в нашем корпусе. Мы создадим двумерный массив из 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_crossentropy . И мы хотим видеть результаты в виде точности, поэтому в качестве значения атрибута metrics acc

Краткое описание модели выглядит следующим образом:

 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 100 = 4400 . Результатом слоя внедрения будет 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 - хорошая отправная точка для новичков, поскольку он позволяет быстро создавать модели глубокого обучения, чрезвычайно важно знать, как работает Keras Functional API. Большинство передовых моделей глубокого обучения, включающих несколько входов и выходов, используют функциональный API.

В этом разделе мы увидим, как мы можем реализовать слой внедрения с помощью Keras Functional API.

Остальная часть скрипта остается такой же, как и в предыдущем разделе. Единственное изменение будет в разработке модели глубокого обучения. Давайте реализуем ту же модель глубокого обучения, которую мы реализовали в предыдущем разделе, с помощью 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 

В сводке модели вы можете увидеть входной слой как отдельный слой перед встраиваемым слоем. В остальном модель осталась прежней.

Наконец, процесс подбора и оценки модели такой же, как и в Sequential 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. Мы реализовали пользовательские встраивания слов, а также использовали предварительно обученные встраивания слов для решения простой задачи классификации. Наконец, мы также увидели, как реализовать встраивание слов с помощью Keras Functional API.