Привет, ребята,
В этой статье вы узнаете, как обучить свою собственную модель классификации текста с нуля, используя Тензорный поток всего в пару строк кода.
кратко о классификации текстов
Классификация текста — это часть обработки естественного языка, которая фокусируется на группировании абзаца в предопределенные группы на основе его содержания, например, классификация категорий новостей, будь то спорт, бизнес, музыка и т. д.
чему вы научитесь?
- Одна горячая кодировка
- Вложение слов
- Нейронная сеть со слоем встраивания
- Оценка и тестирование обученной модели
Вышеупомянутые концепции являются фундаментальными вещами, которые вы должны понимать, когда дело доходит до обработки естественного языка с помощью ТензорФлоу и вы можете применить их к нескольким проектам, основанным на НЛП, поэтому я рекомендую вам прочитать это до конца, чтобы действительно понять это.
Построение анализатора настроений по мере того, как мы учимся
Мы собираемся построить простую модель TensorFlow, которая будет классифицировать отзывы пользователей как положительные или отрицательные в результате эффективного обобщения обучающих данных.
Библиотеки ML, которые нам нужны
Помимо самого Tensorflow, нам также нужны другие библиотеки и инструменты Python для разработки нашей модели, и в этой статье предполагается, что они установлены на вашем компьютере.
Быстрая установка
Если у вас не установлены эти библиотеки, вот краткое руководство по установке с pip;
pip install numpy
pip install tensorflow
pip install matplotlib
Теперь, когда все установлено, теперь мы готовы запачкать руки и начать сборку нашей модели.
Начиная
Прежде всего, нам нужно импортировать всю необходимую библиотеку, которую мы только что установили в нашу кодовую базу;
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
Набор данных
Набор данных может иметь различные форматы файлов (csv, json, sql), но в этой статье мы будем использовать только одномерный массив образцов сообщений с отзывами клиентов, как показано ниже;
data_x = [
'good', 'well done', 'nice', 'Excellent',
'Bad', 'OOps I hate it deadly', 'embrassing',
'A piece of shit']
Таким образом, мы можем иметь нашу метку в виде массива 1D numpy из 0 и 1, где 1 означает положительный отзыв, а 0 — отрицательный отзыв, организованный в соответствии с обучающими данными (data_x), как показано ниже;
data_x = [
'good', 'well done', 'nice', 'Excellent',
'Bad', 'OOps I hate it deadly', 'embrassing',
'A piece of shit']
label_x = np.array([1,1,1,1, 0,0,0,0])
Инжиниринг данных — одно горячее кодирование
Машина понимает только числа, и это не меняется, когда дело доходит до обучения текстовых данных, поэтому, чтобы иметь возможность обучать их, нам нужен способ иметь числовое представление нашего набора текстовых данных, где в игру вступает горячее кодирование.
Tensorflow предоставляет встроенный метод, чтобы помочь вам, чтобы вы могли узнать больше о нем, посетив одна горячая кодировка документови вот как вы помещаете это в код;
data_x = [
'good', 'well done', 'nice', 'Excellent',
'Bad', 'OOps I hate it deadly', 'embrassing',
'A piece of shit']
label_x = np.array([1,1,1,1, 0,0,0,0])
one_hot_x = [tf.keras.preprocessing.text.one_hot(d, 50) for d in data_x]
print(one_hot_x)
Вот вывод;
[[21], [9, 34], [24], [20], [28], [41, 26, 9, 17, 26], [36], [9, 41]]
С помощью всего одной строки кода понимания списка мы смогли получить числовое представление наших наборов текстовых данных.
Инжиниринг данных — заполнение
Если вы посмотрите внимательно, вы заметите, что это привело к массивам разных размеров, это связано с разной длиной отдельных обучающих данных.
Это нехорошо, нам нужно убедиться, что наши элементы обучающих данных имеют одинаковую длину, чтобы иметь возможность их обучать, поэтому необходимо выполнять заполнение, чтобы нормализовать их до определенной стандартной длины.
то, что будет делать заполнение, – это расширять массивы с длиной ниже стандартной длины, чтобы сравняться с ней, добавляя 0 и удаляя лишние элементы для тех, длина которых превышает;
Теперь, учитывая характер нашего набора данных, давайте установим нашу стандартную длину (max_len) равной четырем (4) для наших обучающих данных. Вот как вы поместите это в код:
макслен является параметром стандартной длины, и пусть он устанавливается соответствующим образом;
data_x = [
'good', 'well done', 'nice', 'Excellent',
'Bad', 'OOps I hate it deadly', 'embrassing',
'A piece of shit']
label_x = np.array([1,1,1,1, 0,0,0,0])
# one hot encoding
one_hot_x = [tf.keras.preprocessing.text.one_hot(d, 50) for d in data_x]
# padding
padded_x = tf.keras.preprocessing.sequence.pad_sequences(one_hot_x, maxlen=4, padding = 'post')
print(padded_x)
Ваш вывод будет выглядеть следующим образом;
array([[21, 0, 0, 0], [ 9, 34, 0, 0], [24, 0, 0, 0], [20, 0, 0, 0],[28, 0, 0, 0], [26, 9, 17, 26], [36, 0, 0, 0],[ 9, 41, 0, 0]], dtype=int32)
Как мы видим, теперь наши обучающие данные спроектированы, теперь они готовы к обучению;
Построение модели
Я предполагаю, что у вас есть основы TensorFlow, и вы знакомы с последовательными моделями, все будет как обычно с исключением слоя внедрения;
Почему встраиваемый слой?
Данные, которые мы спроектировали, представляют собой просто массивы чисел, а не массивы, и их можно связать, насколько один похож на другой, сравнивая числа, поэтому нам нужен слой встраивания, который помогает превратить эти числа в нечто большее. осмысленно, превратив их в плотные векторы фиксированного размера, отношения которых мы можем вычислить;
Слой внедрения получает три основных параметра
- input_dim (сумма уникальных слов в вашем корпусе)
- output_dim (размер соответствующих плотных векторов)
- input_length (стандартная длина входных данных)
Вот пример;
sample_data = np.array([[1], [4]], dtype='int32')
emb_layer = tf.keras.layers.Embedding(50, 4, input_length=4)
print(emb_layer(sample_data))
Вот как будет выглядеть ваш вывод;
f.Tensor(
[[[-0.04779602 -0.01631527 0.01087242 0.00247218]]
[[-0.03402965 0.02020274 0.02596027 -0.00916996]]], shape=(2, 1, 4), dtype=float32)
Теперь вместо кучи бессмысленных нулей мы можем иметь векторное представление, подобное этому, для наших данных, и это то, что делает слой внедрения, теперь давайте поместим его в наш проект;
model = tf.keras.models.Sequential([
tf.keras.layers.Embedding(50, 8, input_length=4),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(1, activation='sigmoid')
])
Выше приведена полная архитектура нашей модели классификации текста с добавлением Flatten(), который просто сводит многомерные тензорные векторы в 2D, и последний плотный слой, который является решающим узлом для нашей модели классификации, который будет иметь последнее слово, будет ли отзыв положительный или отрицательный
Теперь, когда мы инициализировали нашу модель, мы завершаем настройку, указав алгоритм оптимизатора, который будет использоваться, и категорию потерь, которые будут рассчитываться во время оптимизации;
model.compile(optimizer='adam', loss='binary_crossentropy',
metrics=['accuracy'])
model.summary()
Выход
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
embedding (Embedding) (None, 4, 8) 400
_________________________________________________________________
flatten (Flatten) (None, 32) 0
_________________________________________________________________
dense (Dense) (None, 1) 33
=================================================================
Total params: 433
Trainable params: 433
Non-trainable params: 0
_________________________________________________________________
Модель обучения
Теперь, когда мы закончим настройку нашей модели, мы можем начать обучение нашей модели. Поскольку наши данные очень короткие, нам обычно не требуется много эпох для ее обучения, но давайте подойдем к 1000 эпохам и визуализируем кривую обучения.
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
data_x = [
'good', 'well done', 'nice', 'Excellent',
'Bad', 'OOps I hate it deadly', 'embrassing',
'A piece of shit']
label_x = np.array([1,1,1,1, 0,0,0,0])
# one hot encoding
one_hot_x = [tf.keras.preprocessing.text.one_hot(d, 50) for d in data_x]
# padding
padded_x = tf.keras.preprocessing.sequence.pad_sequences(one_hot_x, maxlen=4, padding = 'post')
# Architecting our Model
model = tf.keras.models.Sequential([
tf.keras.layers.Embedding(50, 8, input_length=4),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(1, activation='sigmoid')
])
# specifying training params
model.compile(optimizer='adam', loss='binary_crossentropy',
metrics=['accuracy'])
history = model.fit(padded_x, label_x, epochs=1000,
batch_size=2, verbose=0)
# plotting training graph
plt.plot(history.history['loss'])
Вывод обучающего графика будет выглядеть так, как показано ниже;
Это выглядит довольно хорошо, показывая, что наше обучение смогло эффективно минимизировать потери, и наша модель готова к тестированию.
Оценка модели
Давайте создадим простую функцию для прогнозирования новых слов, используя только что созданную модель, это будет не так умно, поскольку наши данные были очень короткими.
def predict(word):
one_hot_word = [tf.keras.preprocessing.text.one_hot(word, 50)]
pad_word = tf.keras.preprocessing.sequence.pad_sequences(one_hot_word, maxlen=4, padding='post')
result = model.predict(pad_word)
if result[0][0]>0.1:
print('you look positive')
else:
print('damn you\'re negative')
Давайте протестируем вызов метода прогнозирования с разными параметрами слова.
>>> predict('this tutorial is cool')
you look positive
>>> predict('This tutorial is bad as me ')
damn you're negative
Наша модель смогла успешно классифицировать положительные и отрицательные отзывы, что показывает, что она действительно чему-то научилась.
оригинальная статья можно найти на моем личный блог
Я также рекомендую прочитать это
Ссылка на источник
