Как обучить нейронную сеть анализу настроений

Автор выбрал программу Write for DOnations.

Введение

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

Чтобы провести анализ настроений, вы должны запустить вычислительную программу для распознавания и классификации мнений в фрагменте текста, например, чтобы определить, положительно или отрицательно относится автор (или рецензент) к заданной теме (в данном случае к фильму). ). Как подобласть интеллектуального анализа мнений анализ настроений фокусируется на извлечении эмоций и мнений по определенной теме из структурированных, полуструктурированных или неструктурированных текстовых данных. Как и в случае с другими моделями сбора мнений, вы можете использовать анализ настроений для отслеживания мнений о бренде и продукте, а также для понимания потребностей клиентов. Анализ настроений фокусируется на полярности текста (положительный, отрицательный или нейтральный), а также на выявлении конкретных чувств и эмоций рецензента (сердитый, счастливый, грустный и т. д., как определено моделью), срочности и даже намерения (заинтересованы или не заинтересованы).

В этом руководстве вы создадите нейронную сеть, которая предсказывает настроение рецензий на фильмы с помощью keras. Ваша модель разделит обзоры на две категории (положительные и отрицательные) с использованием набора данных обзоров Международной базы данных фильмов (IMDb), который содержит 50 000 обзоров фильмов. К концу этого руководства вы создадите модель глубокого обучения и обучите нейронную сеть выполнять анализ настроений.

Предпосылки

Один экземпляр сервера Ubuntu 22.04 с оперативной памятью не менее 8 ГБ. Для этого сервера потребуется пользователь без полномочий root с привилегиями sudo и настроенным брандмауэром, который вы можете настроить, следуя нашему руководству по начальной настройке сервера.
Python 3, pip и модуль Python venv, установленные на сервере, которые можно настроить, выполнив шаги 1 и 2 нашего руководства «Как установить Python 3 и настроить среду программирования».
Блокнот Jupyter установлен и работает на удаленном сервере, который можно настроить с помощью инструкции по установке, запуску и подключению к блокноту Jupyter на удаленном сервере.
Современный веб-браузер, который вы будете использовать для доступа к Jupyter Notebook.
Фундаментальное понимание моделей машинного обучения и глубокого обучения. Узнайте больше в статье Введение в машинное обучение.

Шаг 1 — Подготовка среды Jupyter Notebook

Jupyter Notebook предоставляет интерактивную вычислительную среду, поэтому его часто используют для запуска моделей глубокого обучения, а не Python в терминале командной строки. В Jupyter Notebook команды и выходные данные отображаются в одном блокноте, что позволяет вам документировать свои мысли во время разработки процесса анализа.

Чтобы следовать этому руководству в блокноте Jupyter, вам нужно будет открыть новый блокнот и установить необходимые зависимости, что вы и сделаете на этом шаге.

Примечание. Если вы следуете руководству на удаленном сервере, вы можете использовать переадресацию портов для доступа к блокноту Jupyter в браузере на локальном компьютере.

Откройте терминал и введите следующую команду:

ssh -L 8888:localhost:8888  your_non_root_user@your_server_ip

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

Вы настроили среду Jupyter Notebook на своем сервере в предварительных условиях. После входа на сервер активируйте виртуальную среду:

source ~/environments/my_env/bin/activate

Затем запустите приложение Jupyter Notebook, чтобы запустить приложение:

jupyter notebook

После запуска и подключения к нему вы получите доступ к пользовательскому интерфейсу в своем браузере. В раскрывающемся меню «Создать» выберите параметр Python3 (ipykernel), который откроет новую вкладку с блокнотом Python без названия. Назовите файл neural_network.ipynb, так как вы будете запускать свой код в этом файле.

Затем в первой ячейке блокнота Jupyter вашего браузера используйте pip для установки необходимых зависимостей для обработки ваших данных:

!pip install numpy
!pip install tensorflow

Зависимость numpy используется для управления массивами в линейной алгебре. В этом руководстве вы будете использовать его для управления набором данных IMDb в форме массива, вызывая следующие функции:

Зависимость tensorflow позволяет обучать и развертывать модель глубокого обучения в Python. При установке tensorflow также устанавливается keras, который работает поверх TensorFlow и вводит уровень абстракции между TensorFlow и пользователем, чтобы обеспечить быструю разработку моделей глубокого обучения. В этом руководстве используются tensorflow и keras для всего процесса обучения и развертывания анализа тональности.

После добавления двух команд в блокнот Jupyter нажмите кнопку «Выполнить», чтобы запустить их.

Ваш блокнот Jupyter предоставит текущий вывод, чтобы указать, что каждая зависимость загружается. Новая ячейка ввода будет доступна ниже этого вывода, где вы будете запускать следующие строки кода.

Когда зависимости закончат загрузку, вы импортируете их. Добавьте эти строки в следующую ячейку и нажмите «Выполнить»:

import numpy as np
from keras.utils import to_categorical
from keras import models
from keras import layers

Примечание. При выполнении этих команд вы можете получить предупреждение о библиотеках TensorFlow и TensorRT. Как правило, Tensorflow работает с процессорами, графическими процессорами и TPU. В предупреждающей ошибке указано, что установленная версия TensorFlow может использовать операции AVX и AVX2, что может ускорить процесс. Это предупреждение не является ошибкой, а является примечанием о том, что TensorFlow использует преимущества вашего процессора для дополнительной скорости.

Установка инструмента keras включает встроенную базу данных IMDB. Набор данных разделен на поезд/тест 50/50. В этом руководстве вы настроите разделение 80/20, чтобы предотвратить переобучение нейронной сети. Таким образом, вы объедините данные в данные и цели после загрузки, чтобы вы могли разделить 80/20 позже в учебнике. Добавьте эти строки в новую ячейку и нажмите «Выполнить»:

from keras.datasets import imdb
(training_data, training_targets), (testing_data, testing_targets) = imdb.load_data(num_words=10000)
data = np.concatenate((training_data, testing_data), axis=0)
targets = np.concatenate((training_targets, testing_targets), axis=0)

Эта ячейка импортирует набор данных IMDb и объединяет обучающие данные с тестовыми данными. По умолчанию набор данных разделен на training_data, training_targets, testing_data и testing_targets.

В вашем блокноте Jupyter будет журнал действий, и вам потребуется несколько минут, чтобы загрузить набор данных:

OutputDownloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz
17464789/17464789 [==============================] - 0s 0us/step

На этом шаге вы подготовили среду Jupyter Notebook, чтобы можно было исследовать этот набор данных на наличие шаблонов, предположений и тестовых аномалий. Далее вы проведете исследовательский анализ данных по всему набору данных.

Шаг 2 — Анализ набора данных

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

Ваша первая задача с этим набором данных — получить типы вывода и количество уникальных слов. Чтобы получить эту информацию, выполните следующие строки в новой ячейке:

print("The output categories are", np.unique(targets))
print("The number of unique words is", len(np.unique(np.hstack(data))))

В этой ячейке отображается количество уникальных настроений в наборе данных (положительное [1] или отрицательное [0]) и количество уникальных слов, использованных в обзоре.

Будет напечатан следующий вывод:

OutputThe output categories are [0 1]
The number of unique words is 9998

В первой строке этого вывода указано, что фильмы помечены как положительные (1) или отрицательные (0). Во второй строке указано, что в наборе данных 9998 уникальных слов.

Далее вы определите среднюю длину слов для обзоров фильмов и стандартное отклонение слов. Для этого запустите эти строки кода в новой ячейке:

length = [len(i) for i in data]
print("The Average Review length is", np.mean(length))
print("The Standard Deviation is", round(np.std(length)))

В этой ячейке будет напечатана средняя длина обзора и стандартное отклонение для набора данных:

OutputThe Average Review length is 234.75892
The Standard Deviation is 173

Эта оценка показывает, что средняя длина отзыва составляет 234 слова со стандартным отклонением 173.

Далее вы напечатаете элемент набора данных (первый индекс), запустив эти строки в новой ячейке:

print("Label:", targets[0])
print(data[0])

Пара отзыв-метка фильма для первого элемента в наборе данных напечатает:

OutputLabel: 1
[1, 14, 22, 16, 43, 530, 973, 1622, 1385, 65, 458, 4468, 66, 3941, 4, 173, 36, 256, 5, 25, 100, 43, 838, 112, 50, 670, 2, 9, 35, 480, 284, 5, 150, 4, 172, 112, 167, 2, 336, 385, 39, 4, 172, 4536, 1111, 17, 546, 38, 13, 447, 4, 192, 50, 16, 6, 147, 2025, 19, 14, 22, 4, 1920, 4613, 469, 4, 22, 71, 87, 12, 16, 43, 530, 38, 76, 15, 13, 1247, 4, 22, 17, 515, 17, 12, 16, 626, 18, 2, 5, 62, 386, 12, 8, 316, 8, 106, 5, 4, 2223, 5244, 16, 480, 66, 3785, 33, 4, 130, 12, 16, 38, 619, 5, 25, 124, 51, 36, 135, 48, 25, 1415, 33, 6, 22, 12, 215, 28, 77, 52, 5, 14, 407, 16, 82, 2, 8, 4, 107, 117, 5952, 15, 256, 4, 2, 7, 3766, 5, 723, 36, 71, 43, 530, 476, 26, 400, 317, 46, 7, 4, 2, 1029, 13, 104, 88, 4, 381, 15, 297, 98, 32, 2071, 56, 26, 141, 6, 194, 7486, 18, 4, 226, 22, 21, 134, 476, 26, 480, 5, 144, 30, 5535, 18, 51, 36, 28, 224, 92, 25, 104, 4, 226, 65, 16, 38, 1334, 88, 12, 16, 283, 5, 16, 4472, 113, 103, 32, 15, 16, 5345, 19, 178, 32]

Эти выходные данные содержат первый обзор набора данных, помеченный как положительный (1), и полный текст в виде целочисленного индекса. По умолчанию текстовые обзоры даются в числовом кодированном виде в виде списка индексов слов на основе целых чисел. Слова в отзывах индексируются в зависимости от того, как часто они встречаются во всем наборе данных. Например, второй по распространенности термин в данных кодируется целым числом 2.

Затем вы извлечете словарь, сопоставив индексы слов с исходными словами, чтобы вы могли прочитать обзор текста. Запустите эти строки в новой ячейке:

index = imdb.get_word_index()
reverse_index = dict([(value, key) for (key, value) in index.items()])
decoded = " ".join( [reverse_index.get(i - 3, "#") for i in data[0]] )
print(decoded)

Этот блок кода будет декодировать числовую форму в читаемый текст. С помощью функции get_word_index() вы получаете dict, сопоставляющий слова с их индексом в наборе данных IMDb. Затем переменная reverse_index содержит словарь, который сопоставляет индексы со словами после обращения индекса слова. Функция dict() создает словарь, в котором значения данных хранятся в виде пар ключ-значение. Последние две строки кода будут декодировать и печатать первую последовательность в наборе данных.

Используя функцию get_word_index(), вы получите следующий вывод:

Output# this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert # is an amazing actor and now the same being director # father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for # and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also # to the two little boy's that played the # of norman and paul they were just brilliant children are often left out of the # list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all

Функция get_word_index() декодирует числовые данные для этого обзора в читаемые слова и заменяет каждое нераспознаваемое слово знаком #.

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

Шаг 3 — Подготовка данных для обучения

На этом этапе вы подготовите набор данных для обучения. Модели глубокого обучения обычно разрабатываются на основе данных, на которых они обучаются.

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

В этом руководстве вы разделите данные на тестовые и обучающие наборы и выполните проектирование функций путем векторизации данных.

В следующей ячейке запустите следующие строки кода, чтобы векторизовать каждый обзор в наборе данных:

def vectorize(sequences, dimension = 10000):
    results = np.zeros((len(sequences), dimension))
    for i, sequence in enumerate(sequences):
        results[i, sequence] = 1
    return results

data = vectorize(data)
targets = np.array(targets).astype("float32")

Сначала вы векторизуете и заполняете каждый отзыв, чтобы каждый отзыв содержал ровно 10 000 номеров. В ходе этого процесса вы заполняете каждый обзор короче 10 000 слов нулями, потому что самый большой обзор в наборе данных имеет примерно такую длину, а нейронная сеть требует, чтобы все входные данные были одинакового размера.

Функция vectorize() принимает два параметра: массив и заданную размерность 10000. Эта функция вызывает метод zeros() из numpy, который возвращает новый массив, заполненный нулями, а затем кодирует остальные данные. С помощью последних двух строк кода вы вызовете определенную функцию для набора данных, а затем преобразуете целевой столбец вашего набора данных в 32-битное число с плавающей запятой. 32-битное число с плавающей запятой — это число с плавающей запятой с точностью около семи цифр. Преобразование целевого столбца в 32-битное число с плавающей запятой повысит точность столбца и модель глубокого обучения за счет расширения.

В качестве последнего шага в подготовке данных вы разделите их на наборы для обучения и тестирования. Вы поместите 40 000 отзывов в обучающий набор и 10 000 — в тестовый набор, обеспечивая разделение 80/20, описанное ранее.

Разделите набор данных, выполнив эти команды в новой ячейке:

test_x = data[:10000]
test_y = targets[:10000]
train_x = data[40000:]
train_y = targets[40000:]

Набор данных был разделен на тестовые и обучающие наборы в соотношении 1:4, при этом цели в обучающем и тестовом наборах сохранены как train_y и test_y, а обзоры — в обучающий и тестовый наборы сохраняются как train_x и test_y соответственно. В дополнение к тестированию и оценке вашей модели с новыми данными, разделение набора данных означает, что ваша модель избежит переобучения, когда алгоритм слишком хорошо моделирует обучающие данные.

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

Шаг 4 — Создание и обучение нейронной сети

Теперь вы можете построить свою нейронную сеть.

Вы начнете с определения типа модели, которую хотите построить. В keras доступно два типа моделей: Model Sequential API и Functional API. В этом руководстве вы будете использовать Sequential API, поскольку он позволяет создавать модели слой за слоем.

Примечание. Для более сложных моделей глубокого обучения следует использовать функциональный API, поскольку последовательный API не позволяет создавать модели с общими слоями или несколькими входными и выходными данными. Однако для этого руководства Sequential API будет достаточно.

Установите свою модель в качестве последовательной модели, выполнив эту команду в новой ячейке:

model = models.Sequential()

Примечание. На этом этапе вы можете получить еще одну ошибку TensorFlow, в которой говорится о необходимости перестроить TensorFlow с соответствующими тегами компилятора. Эта ошибка связана с предыдущей ошибкой и результатами, поскольку пакеты TensorFlow 2.x поддерживают как ЦП, так и ГП, поэтому TensorFlow ищет драйверы ГП. Вы можете смело игнорировать это предупреждение, так как оно не повлияет на результат обучения.

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

Запустите эти строки в новой ячейке, чтобы добавить слои:

# Input - Layer
model.add(layers.Dense(50, activation = "relu", input_shape=(10000, )))
# Hidden - Layers
model.add(layers.Dropout(0.3, noise_shape=None, seed=None))
model.add(layers.Dense(50, activation = "relu"))
model.add(layers.Dropout(0.2, noise_shape=None, seed=None))
model.add(layers.Dense(50, activation = "relu"))
# Output- Layer
model.add(layers.Dense(1, activation = "sigmoid"))
model.summary()

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

На выходном слое вы будете использовать функцию sigmoid, которая сопоставляет значения 0 и 1. Поскольку вывод положительный (1) или отрицательный (0), функция sigmoid гарантирует, что выходной слой выдает результат, который либо <0 или 1.

Наконец, вы позволите keras распечатать сводку модели, которую вы только что построили.

Вы получите краткую информацию об особенностях модели, которую вы только что обучили:

OutputModel: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense (Dense)               (None, 50)                500050    
                                                                 
 dropout (Dropout)           (None, 50)                0         
                                                                 
 dense_1 (Dense)             (None, 50)                2550      
                                                                 
 dropout_1 (Dropout)         (None, 50)                0         
                                                                 
 dense_2 (Dense)             (None, 50)                2550      
                                                                 
 dense_3 (Dense)             (None, 1)                 51        
                                                                 
=================================================================
Total params: 505,201
Trainable params: 505,201
Non-trainable params: 0
_________________________________________________________________

Далее вы скомпилируете и настроите модель для обучения. В качестве показателя оценки вы будете использовать точность. Функция потерь будет вычислять количество, которое модель должна стремиться минимизировать во время обучения. В этом случае вы выбираете binary-crossentropy, потому что потеря кросс-энтропии между истинными и предсказанными метками является отличным показателем для двоичных (0 или 1 ) классификационные приложения.

Чтобы скомпилировать модель, выполните следующие строки в следующей ячейке:

model.compile(
optimizer = "adam",
loss = "binary_crossentropy",
metrics = ["accuracy"]
)

Функция compile() определяет архитектуру модели. В этом определении вы реализуете алгоритм adam в качестве оптимизатора вашей модели. Этот алгоритм представляет собой метод градиентного спуска, основанный на аппроксимации моментов первого и второго порядка. Метрики и параметры потерь очень тесно связаны. В то время как параметр метрики определяет, как оценивать производительность вашей модели, параметр потерь определяет количество, которое модель стремится минимизировать во время обучения. Показателем здесь является accuracy (доля предсказаний, которые модель получает правильно), а потеря — binary_crossentropy (показатель между метками и предсказаниями, используемый, когда есть только две метки). классы [положительный 1 и отрицательный 0]).

Теперь вы сможете обучить свою модель. Для этого вы будете использовать batch_size 32 и всего две эпохи. Размер пакета — это количество выборок, которые будут распространяться по нейронной сети, а эпоха — это итерация по всем обучающим данным. Больший размер пакета обычно подразумевает более быстрое обучение, но иногда сходится медленнее. И наоборот, меньший размер пакета медленнее в обучении, но может сходиться быстрее.

Теперь вы начнете обучать свою модель, чтобы привести все параметры к правильному значению, чтобы сопоставить ваши входные данные с вашими входными данными. Запустите эти строки в следующей ячейке:

results = model.fit(
train_x, train_y,
epochs= 2,
batch_size = 32,
validation_data = (test_x, test_y)
)

Вы будете обучать свою модель с помощью функции .fit(). Эта функция обучает модель глубокого обучения фиксированному количеству итераций в наборе данных. Функция принимает два обязательных параметра:

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

К другим параметрам относятся следующие:

эпохи (количество эпох для обучения модели, где эпоха представляет собой итерацию по всем предоставленным данным).
batch_size (количество образцов на обновление градиента).
validation_data (данные, по которым модель будет оценивать потери в конце каждой эпохи).

Этот код обучает модель, используя две эпохи и размер пакета 32, что означает, что весь набор данных будет проходить через нейронную сеть дважды с использованием 32 обучающих примеров в каждой итерации. Данные проверки задаются как test_x и test_y.

Примечание. Обучение модели анализа тональности требует большого объема оперативной памяти. Если вы запускаете это руководство на сервере с 8 ГБ ОЗУ, вы можете получить следующее предупреждение: Распределение x превышает 10% свободной системной памяти. Вы можете проигнорировать это предупреждение, когда оно появляется, и продолжить обучение, потому что в нем говорится только о том, что обучение занимает значительный объем свободной системной памяти и не влияет на остальную часть руководства.

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

Шаг 5 — Оценка модели

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

Существует четыре основных показателя оценки модели для модели классификации машинного обучения: точность, точность, полнота и оценка F1.

Точность — это часто используемый показатель производительности, поскольку он оценивает долю прогнозов, которые ваша модель сделала верными. Точность определяется путем деления количества правильных прогнозов на общее количество прогнозов. В этом руководстве вы будете использовать точность для оценки вашей модели.

Точность в контексте этой модели будет относиться к положительным отзывам о фильмах, которые были правильно предсказаны по отношению к общему количеству предсказанных положительных отзывов о фильмах. Отзыв — это доля положительных отзывов о фильмах, которые были правильно предсказаны, на общее количество отзывов о фильмах, оцененных в наборе данных. Precision отвечает на вопрос: Сколько из всех отзывов о фильмах, отмеченных вашей моделью как положительные, были на самом деле положительными?. Напротив, припоминание отвечает на вопрос Сколько из всех действительно положительных отзывов о фильмах ваша модель отметила как положительные?. Оценка F1 представляет собой средневзвешенное значение результатов точности и полноты. Таким образом, он учитывает любые отзывы, которые были классифицированы неправильно.

В этом руководстве вы оцените производительность вашей модели, используя ее точность. Запустите эти строки кода в следующей ячейке:

scores = model.evaluate(test_x, test_y, verbose=0)
print("Accuracy: %.2f%%" % (scores[1]*100))

Этот код сохраняет оценку точности модели в переменной с именем scores и выводит ее на экран. Функция .evaluate принимает три параметра.

x_test: столбец функций для тестового набора данных.
y_test: целевой столбец для тестового набора данных.
подробный: способ многословия.

Следующий вывод будет напечатан с точностью:

OutputAccuracy: 86.59%

Точность этой обученной модели составляет 86,59%.

Этот показатель точности указывает на то, что эта модель правильно предсказывает, будет ли отзыв положительным или отрицательным примерно в девяти случаях из десяти. Вы можете продолжить работу над своим кодом, чтобы попытаться повысить точность классификатора. Чтобы ваша модель работала лучше и повышала точность, вы можете увеличить количество эпох или размер пакета для вашей модели.

Модели глубокого обучения (и модели машинного обучения) столь же эффективны, как и данные, которые вы им предоставляете. Таким образом, повышение точности вашей модели часто достигается за счет добавления дополнительных данных. Однако данные, используемые для этой модели, являются встроенными и не могут быть изменены. В этом случае вы можете повысить точность модели, добавив в модель больше слоев или увеличив количество эпох (количество раз, когда вы пропускаете весь набор данных через нейронную сеть) на шаге 4.

Чтобы увеличить количество эпох, замените количество epochs в ячейке model.fit() с 2 на 3 (или другое число), затем повторно запустите эту ячейку и следующие за ней ячейки:

results = model.fit(
train_x, train_y,
epochs= 3,
batch_size = 32,
validation_data = (test_x, test_y)
)

Количество эпох увеличено, а это значит, что обучающие данные будут проходить через нейросеть в общей сложности три раза, а модель получит дополнительную возможность учиться на данных. При повторном запуске функции model.evaluate() вы получите новый вывод с обновленным уровнем точности.

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

Заключение

В этом руководстве вы научили нейронную сеть классифицировать отзывы о фильмах как положительные или отрицательные, используя keras. Вы использовали набор данных классификации настроений IMDb, собранный исследователями Стэнфордского университета. Набор данных содержит один из предварительно загруженных наборов данных keras для бинарной классификации настроений. Вы можете получить доступ к набору данных, набору из 25 000 крайне поляризованных обзоров фильмов для обучения и еще 25 000 для тестирования. Вы просмотрели этот набор данных, чтобы разработать большую модель нейронной сети для анализа настроений.

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

Чтобы использовать свой опыт работы с keras и TensorFlow, вы можете следовать нашему руководству «Как построить модель глубокого обучения для прогнозирования удержания сотрудников с помощью Keras и TensorFlow».