Привет, ребята,
В этой статье вы узнаете, как обучать свою собственную модель классификации текста с нуля, используя Tensorflow Всего за пару строк кода.
Краткое описание текстовой классификации
Текстовая классификация – это подразделение обработки естественного языка, которая фокусируется на группировании абзаца в предопределенные группы на основе его содержания, например, классификации категорий новостей, о том, являются ли его спорт, бизнес, музыка и т. Д.
Чему ты научишься?
- Одна горячая кодировка
- Слово внедрение
- Нейронная сеть с встроенным слоем
- Оценка и тестирование обученной модели
В вышеприведенных упоминаниях концепции являются фундаментальными вещами, которые вы должны понять, когда речь заходит о обработке естественного языка с Tensorflow И вы можете применить их к нескольким проектам на основе NLP, поэтому я рекомендую вам прочитать это до конца, чтобы действительно понять это.
Строительство настроений анализатор Как мы учимся
Мы собираемся создать простую модель TensorFlow, которая будет классифицировать отзывы пользователя как положительные или отрицательные в результате эффективного обобщения данных обучения.
МЛ библиотеки нам нужны
Помимо самого 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), но в этой статье мы будем использовать лишь 1D -массив образцов сообщений по обзору клиентов, как показано ниже;
data_x = [ 'good', 'well done', 'nice', 'Excellent', 'Bad', 'OOps I hate it deadly', 'embrassing', 'A piece of shit']
SAMWISE Мы можем иметь нашу метку в качестве 1D Numpy Array 0, и 1, в соответствии с которым 1 выступает для положительного обзора, а 0 означает отрицательный обзор, соответствующий учебным данным (DAGA_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]]
Имея только одну строку кода понимания списка, мы смогли иметь числовое представление наших текстовых наборов данных.
Техника данных – прокладка
Если вы внимательно посмотрите, вы заметите, что это привело к массивам разных размеров, это связано с различной длиной индивидуальных данных обучения.
Это нехорошо, мы должны убедиться, что наши учебные данные имеют одинаковую длину, чтобы обучать ее, поэтому необходимо выполнить прокладку, чтобы нормализовать их до определенной стандартной длины.
То, что будет делать заполнение, – это расширение массивов с длиной ниже стандартной длины, чтобы равняться им, добавив 0s и удаляет дополнительный элемент для тех, кто превышает длину;
Теперь с характером нашего набора данных давайте установим нашу стандартную длину (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)
Теперь вместо того, чтобы иметь кучу бессмысленных 0s, у нас может быть векторное представление, подобное этим, для наших данных, и это то, что встроенный слой делает теперь давайте поместим его в наш проект;
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')
])
Выше представляет собой полную архитектуру нашей модели классификации текста с добавлением щедрости (), который просто уменьшает более высокие тензовые векторы в 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
Наша модель смогла успешно классифицировать положительные и отрицательные отзывы, которые показывают, что она действительно чему -то научилась.
А оригинальная статья можно найти на моем личный блог
Я также рекомендую прочитать это
- Обнаружение плагиата с помощью Pysimilar in python
- Как проанализировать твиты эмоций с помощью Python
- Перевод языков с помощью Python
- Сделайте свой собственный детектор плагиата с нуля в Python
Оригинал: “https://dev.to/kalebu/beginners-guide-to-tensorflow-text-classification-using-python-20d6”