【Перевод】Научит вас реализовывать классификацию текста в Python.

задняя часть Python

Автор: Шивам Бансал

Перевод: Шэнь Либинь

Вычитка: Дин Наня

Эта статья о2300Персонаж,Рекомендуемое чтение8 минут.

В этой статье будет подробно рассмотрена проблема классификации текста и реализован процесс в Python.

введение

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

  • Анализ популярных настроений в социальных сетях

  • Различать спам и не спам

  • Автоматически помечайте запросы клиентов

  • Классифицировать новостные статьи по темам

содержание

В этой статье будет подробно рассмотрена проблема классификации текста и реализован процесс на Python:

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

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

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

2. Обучение модели:Последним шагом является моделирование, при котором модель машинного обучения обучается с использованием помеченного набора данных.

3. Дальнейшее улучшение производительности классификатора:В этой статье также будут обсуждаться различные подходы к повышению производительности текстовых классификаторов.

Уведомление:В этой статье не рассматриваются задачи НЛП подробно. Если вы хотите сначала ознакомиться с основами, вы можете прочитать эту статью.

https://www.analyticsvidhya.com/blog/2017/01/ultimate-guide-to-understand-implement-natural-language-processing-codes-in-python/

подготовь свою машину

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

  • Pandas:https://pandas.pydata.org/pandas-docs/stable/install.html

  • Scikit-learn:http://scikit-learn.org/stable/install.html

  • XGBoost:http://xgboost.readthedocs.io/en/latest/build.html

  • TextBlob:http://textblob.readthedocs.io/en/dev/install.html

  • Keras:https://keras.io/#installation

#Импорт библиотек, необходимых для предварительной обработки наборов данных, разработки функций и обучения моделей.

from sklearn import model_selection, preprocessing, linear_model, naive_bayes, metrics, svm

from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer

from sklearn import decomposition, ensemble

import pandas, xgboost, numpy, textblob, string

from keras.preprocessing import text, sequence

from keras import layers, models, optimizers

1. Подготовьте набор данных

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

https://gist.github.com/kunalj101/ad1d9c58d338e20d09ff26bcc06c4235

Этот набор данных содержит 3,6 млн текстовых комментариев и их меток, и мы используем только небольшую часть данных. Сначала загрузите загруженные данные в структуру данных pandas (dataframe), содержащую два столбца (текст и метки).

Ссылка на набор данных:

https://drive.google.com/drive/folders/0Bz8a_Dbh9Qhbfll6bVpmNUtUcFdjYmF2SEpmZUZUcVNiMUw1TWN6RDV3a0JHT3kxLVhVR2M

#загрузить набор данных

data = open('data/corpus').read()

labels, texts = [], []

for i, line in enumerate(data.split("\n")):

content = line.split()

labels.append(content[0])

texts.append(content[1])

# Создайте фрейм данных со столбцами с именами text и label

trainDF = pandas.DataFrame()

trainDF['text'] = texts

trainDF['label'] = labels

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

# Разделить набор данных на набор для обучения и набор для проверки

train_x, valid_x, train_y, valid_y = model_selection.train_test_split(trainDF['text'], trainDF['label'])

# метка закодирована как целевая переменная

encoder = preprocessing.LabelEncoder()

train_y = encoder.fit_transform(train_y)

valid_y = encoder.fit_transform(valid_y)

2. Разработка функций

Далее идет проектирование признаков, когда исходные данные преобразуются в векторы признаков, а новые признаки создаются из существующих данных. Чтобы выбрать важные функции из набора данных, есть несколько способов:

  • считать вектор как признак

  • Векторы TF-IDF как признаки

    • уровень одного слова

    • Несколько уровней слов (N-грамм)

    • уровень части речи

  • вложения слов как функции

  • Функции на основе текста/NLP

  • Тематические модели как функции

Давайте посмотрим, как они реализованы по отдельности:

2.1 Подсчет векторов как признаков

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

#Создать объект векторного счетчика

count_vect = CountVectorizer(analyzer='word', token_pattern=r'\w{1,}')

count_vect.fit(trainDF['text'])

# Преобразование обучающего набора и набора проверки с использованием объектов векторного счетчика

xtrain_count =  count_vect.transform(train_x)

xvalid_count =  count_vect.transform(valid_x)

2.2 Векторы TF-IDF как признаки

Баллы TF-IDF представляют относительную важность слов в документе и во всем корпусе. Оценка TF-IDF состоит из двух частей: первая часть представляет собой вычислительный стандарт.частота слов(TF), вторая частьЧастота обратного документа(ИДФ). Который вычисляет общее количество документов в корпусе, деленное на количество документов, содержащих слово, а затем логарифмирует, чтобы получить обратную частоту документов.

TF(t)=(количество раз, когда слово встречается в документе)/(общее количество слов в документе)

IDF(t) = log_e (общее количество документов/общее количество документов, в которых появляется термин)

Векторы TF-IDF могут генерироваться на разных уровнях токенизации (одно слово, часть речи, несколько слов (n-граммы))

  • TF-IDF на уровне слов:Матрица представляет оценку TF-IDF каждого слова в разных документах.

  • Уровень N-грамм TF-IDF:N-граммы представляют собой комбинации нескольких слов вместе, и эта матрица представляет оценку TF-IDF для N-грамм.

  • Уровень части речи TF-IDF:Матрица представляет оценки TF-IDF для нескольких частей речи в корпусе.

#уровень слова tf-idf

tfidf_vect = TfidfVectorizer(analyzer='word', token_pattern=r'\w{1,}', max_features=5000)

tfidf_vect.fit(trainDF['text'])

xtrain_tfidf =  tfidf_vect.transform(train_x)

xvalid_tfidf =  tfidf_vect.transform(valid_x)

# уровень ngram tf-idf

tfidf_vect_ngram = TfidfVectorizer(analyzer='word', token_pattern=r'\w{1,}', ngram_range=(2,3), max_features=5000)

tfidf_vect_ngram.fit(trainDF['text'])

xtrain_tfidf_ngram =  tfidf_vect_ngram.transform(train_x)

xvalid_tfidf_ngram =  tfidf_vect_ngram.transform(valid_x)

#Часть речи уровень tf-idf

tfidf_vect_ngram_chars = TfidfVectorizer(analyzer='char', token_pattern=r'\w{1,}', ngram_range=(2,3), max_features=5000)

tfidf_vect_ngram_chars.fit(trainDF['text'])

xtrain_tfidf_ngram_chars =  tfidf_vect_ngram_chars.transform(train_x)

xvalid_tfidf_ngram_chars =  tfidf_vect_ngram_chars.transform(valid_x)

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

Встраивание слов — это форма использования плотных векторов для представления слов и документов. Положение слова в векторном пространстве определяется из контекста слова в тексте. Встраивание слов может быть обучено с использованием самого входного корпуса или может быть сгенерировано с использованием предварительно обученной модели встраивания слов. модели: Glove, FastText, Word2Vec. Все они могут быть загружены и использованы в режиме трансферного обучения. Чтобы узнать больше о встраиваниях слов, вы можете посетить:

https://www.analyticsvidhya.com/blog/2017/06/word-embeddings-count-word2veec/

Далее мы представим, как использовать предварительно обученную модель встраивания слов в модель, Есть четыре основных шага:

1. Загрузите предварительно обученную модель встраивания слов

2. Создайте объект токенизатора

3. Преобразование текстовых документов в последовательности токенов и их заполнение

4. Создайте карту сегментации слов и их соответствующих вложений

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

embeddings_index = {}

for i, line in enumerate(open('data/wiki-news-300d-1M.vec')):

values = line.split()

embeddings_index[values[0]] = numpy.asarray(values[1:], dtype='float32')

#Создать токенизатор

token = text.Tokenizer()

token.fit_on_texts(trainDF['text'])

word_index = token.word_index

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

train_seq_x = sequence.pad_sequences(token.texts_to_sequences(train_x), maxlen=70)

valid_seq_x = sequence.pad_sequences(token.texts_to_sequences(valid_x), maxlen=70)

#Создать карту встраивания сегментации слов

embedding_matrix = numpy.zeros((len(word_index) + 1, 300))

for word, i in word_index.items():

embedding_vector = embeddings_index.get(word)

if embedding_vector is not None:

embedding_matrix[i] = embedding_vector

2.4 Функции, основанные на тексте/NLP

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

  • Количество терминов для документа — общее количество терминов в документе.

  • Подсчет частей речи в документе — общее количество частей речи в документе.

  • Средняя плотность слов в документе -- средняя длина слов, используемых в документе.

  • Знаки пунктуации в полной статье — общее количество знаков препинания в документе.

  • Количество прописных букв во всей статье — количество заглавных слов в документе.

  • Вхождения заголовка в полной статье - общее количество соответствующих тем (заголовков) в документе

  • Частотное распределение тегов частей речи

    • количество существительных

    • количество глаголов

    • количество прилагательных

    • количество наречий

    • количество местоимений

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

trainDF['char_count'] = trainDF['text'].apply(len)

trainDF['word_count'] = trainDF['text'].apply(lambda x: len(x.split()))

trainDF['word_density'] = trainDF['char_count'] / (trainDF['word_count']+1)

trainDF['punctuation_count'] = trainDF['text'].apply(lambda x: len("".join(_ for _ in x if _ in string.punctuation)))

trainDF['title_word_count'] = trainDF['text'].apply(lambda x: len([wrd for wrd in x.split() if wrd.istitle()]))

trainDF['upper_case_word_count'] = trainDF['text'].apply(lambda x: len([wrd for wrd in x.split() if wrd.isupper()]))

trainDF['char_count'] = trainDF['text'].apply(len)

trainDF['word_count'] = trainDF['text'].apply(lambda x: len(x.split()))

trainDF['word_density'] = trainDF['char_count'] / (trainDF['word_count']+1)

trainDF['punctuation_count'] = trainDF['text'].apply(lambda x: len("".join(_ for _ in x if _ in string.punctuation)))

trainDF['title_word_count'] = trainDF['text'].apply(lambda x: len([wrd for wrd in x.split() if wrd.istitle()]))

trainDF['upper_case_word_count'] = trainDF['text'].apply(lambda x: len([wrd for wrd in x.split() if wrd.isupper()]))

pos_family = {

'noun' : ['NN','NNS','NNP','NNPS'],

'pron' : ['PRP','PRP$','WP','WP$'],

'verb' : ['VB','VBD','VBG','VBN','VBP','VBZ'],

'adj' :  ['JJ','JJR','JJS'],

'adv' : ['RB','RBR','RBS','WRB']

}

#Проверить и получить количество тегов частей речи для слов в конкретном предложении

def check_pos_tag(x, flag):

cnt = 0

try:

wiki = textblob.TextBlob(x)

for tup in wiki.tags:

ppo = list(tup)[1]

if ppo in pos_family[flag]:

cnt += 1

except:

pass

return cnt

trainDF['noun_count'] = trainDF['text'].apply(lambda x: check_pos_tag(x, 'noun'))

trainDF['verb_count'] = trainDF['text'].apply(lambda x: check_pos_tag(x, 'verb'))

trainDF['adj_count'] = trainDF['text'].apply(lambda x: check_pos_tag(x, 'adj'))

trainDF['adv_count'] = trainDF['text'].apply(lambda x: check_pos_tag(x, 'adv'))

trainDF['pron_count'] = trainDF['text'].apply(lambda x: check_pos_tag(x, 'pron'))

2.5 Тематические модели как функции

Тематическая модель — это метод определения фраз (тем) из набора документов, содержащих важную информацию. Я использовал LDA для создания функций тематической модели. LDA — это итеративная модель, которая начинается с фиксированного количества тем, каждая тема представляет собой распределение слов, а каждый документ представляет собой распределение тем. Хотя сама по себе токенизация бессмысленна, вероятностное распределение слов, выраженных по темам, может передать идею документа. Чтобы узнать больше о тематических моделях, посетите:

https://www.analyticsvidhya.com/blog/2016/08/beginners-guide-to-topic-modeling-in-python/

Давайте посмотрим на текущий процесс тематической модели:

#поезд тематическая модель

lda_model = decomposition.LatentDirichletAllocation(n_components=20, learning_method='online', max_iter=20)

X_topics = lda_model.fit_transform(xtrain_count)

topic_word = lda_model.components_

vocab = count_vect.get_feature_names()

#Визуальная тематическая модель

n_top_words = 10

topic_summaries = []

for i, topic_dist in enumerate(topic_word):

topic_words = numpy.array(vocab)[numpy.argsort(topic_dist)][:-(n_top_words+1):-1]

topic_summaries.append(' '.join(topic_words)

3. Моделирование

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

  • Наивный байесовский классификатор

  • Линейный классификатор

  • Методы опорных векторов (SVM)

  • Bagging Models

  • Boosting Models

  • неглубокая нейронная сеть

  • глубокая нейронная сеть

    • Сверточная нейронная сеть (CNN)

    • LSTM

    • GRU

    • Двунаправленный RNN

    • Рекуррентная сверточная нейронная сеть (RCNN)

    • Другие варианты глубокой нейронной сети

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

def train_model(classifier, feature_vector_train, label, feature_vector_valid, is_neural_net=False):

# fit the training dataset on the classifier

classifier.fit(feature_vector_train, label)

# predict the labels on validation dataset

predictions = classifier.predict(feature_vector_valid)

if is_neural_net:

predictions = predictions.argmax(axis=-1)

return metrics.accuracy_score(predictions, valid_y)

3.1 Наивный Байес

Используйте структуру sklearn для реализации наивной байесовской модели с различными функциями.

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

Чтобы узнать больше о деталях алгоритма наивного Байеса, нажмите:

A Naive Bayes classifier assumes that the presence of a particular feature in a class is unrelated to the presence of any other feature

# Наивный байесовский анализ с признаками в виде векторов счета

accuracy = train_model(naive_bayes.MultinomialNB(), xtrain_count, train_y, xvalid_count)

print "NB, Count Vectors: ", accuracy

# Наивный Байес с признаками в виде векторов TF-IDF на уровне слов

accuracy = train_model(naive_bayes.MultinomialNB(), xtrain_tfidf, train_y, xvalid_tfidf)

print "NB, WordLevel TF-IDF: ", accuracy

# Наивный Байес с признаками в виде нескольких векторов TF-IDF на уровне слов

accuracy = train_model(naive_bayes.MultinomialNB(), xtrain_tfidf_ngram, train_y, xvalid_tfidf_ngram)

print "NB, N-Gram Vectors: ", accuracy

# Наивный Байес с признаками в виде векторов TF-IDF уровня части речи

accuracy = train_model(naive_bayes.MultinomialNB(), xtrain_tfidf_ngram_chars, train_y, xvalid_tfidf_ngram_chars)

print "NB, CharLevel Vectors: ", accuracy

# результат вывода

NB, Count Vectors:  0.7004

NB, WordLevel TF-IDF:  0.7024

NB, N-Gram Vectors:  0.5344

NB, CharLevel Vectors:  0.6872

3.2 Линейный классификатор

Внедрение линейного классификатора (логистическая регрессия). Логистическая регрессия измеряет взаимосвязь между категориальной зависимой переменной и одной или несколькими независимыми переменными путем оценки вероятностей с использованием логистических/сигмоидных функций. Чтобы узнать больше о логистической регрессии, посетите:

https://www.analyticsvidhya.com/blog/2015/10/basics-logistic-regression/

# Linear Classifier on Count Vectors

accuracy = train_model(linear_model.LogisticRegression(), xtrain_count, train_y, xvalid_count)

print "LR, Count Vectors: ", accuracy

# Линейный классификатор с признаками в виде векторов TF-IDF на уровне слов

accuracy = train_model(linear_model.LogisticRegression(), xtrain_tfidf, train_y, xvalid_tfidf)

print "LR, WordLevel TF-IDF: ", accuracy

# Линейный классификатор с несколькими векторами TF-IDF на уровне слов

accuracy = train_model(linear_model.LogisticRegression(), xtrain_tfidf_ngram, train_y, xvalid_tfidf_ngram)

print "LR, N-Gram Vectors: ", accuracy

# Линейный классификатор с признаками в виде векторов TF-IDF уровня части речи

accuracy = train_model(linear_model.LogisticRegression(), xtrain_tfidf_ngram_chars, train_y, xvalid_tfidf_ngram_chars)

print "LR, CharLevel Vectors: ", accuracy

# результат вывода

LR, Count Vectors:  0.7048

LR, WordLevel TF-IDF:  0.7056

LR, N-Gram Vectors:  0.4896

LR, CharLevel Vectors:  0.7012

3.3 Реализация модели опорных векторов

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

https://www.analyticsvidhya.com/blog/2017/09/understaing-support-vector-machine-example-code/

#SVM с несколькими векторами TF-IDF на уровне слов

accuracy = train_model(svm.SVC(), xtrain_tfidf_ngram, train_y, xvalid_tfidf_ngram)

print "SVM, N-Gram Vectors: ", accuracy

# результат вывода

SVM, N-Gram Vectors:  0.5296

3.4 Bagging Model

Реализация модели случайного леса. Случайный лес — это ансамблевая модель, точнее модель Бэгинга. Это часть семейства древовидных моделей. Чтобы узнать больше о случайных лесах, посетите:

https://www.analyticsvidhya.com/blog/2014/06/introduction-random-forest-simplified/

#RF с функциями в качестве счетных векторов

accuracy = train_model(ensemble.RandomForestClassifier(), xtrain_count, train_y, xvalid_count)

print "RF, Count Vectors: ", accuracy

#features — это RF векторов TF-IDF на уровне слов.

accuracy = train_model(ensemble.RandomForestClassifier(), xtrain_tfidf, train_y, xvalid_tfidf)

print "RF, WordLevel TF-IDF: ", accuracy

# результат вывода

RF, Count Vectors:  0.6972

RF, WordLevel TF-IDF:  0.6988

3.5 Boosting Model

Реализуйте модель Xgboost: модель Boosting — это еще одна модель ансамбля на основе дерева. Повышение — это метаалгоритм ансамбля машинного обучения, который в основном используется для уменьшения смещения модели.Это набор алгоритмов машинного обучения, которые могут превратить слабого ученика в сильного ученика. где слабые ученики обращаются к классификаторам, которые лишь немного коррелируют с истинным классом (немного лучше, чем случайное угадывание). Чтобы узнать больше, посетите:

https://www.analyticsvidhya.com/blog/2016/01/xgboost-algorithm-easy-steps/

# Xgboost с векторами подсчета

accuracy = train_model(xgboost.XGBClassifier(), xtrain_count.tocsc(), train_y, xvalid_count.tocsc())

print "Xgb, Count Vectors: ", accuracy

#features — это Xgboost векторов TF-IDF на уровне слов.

accuracy = train_model(xgboost.XGBClassifier(), xtrain_tfidf.tocsc(), train_y, xvalid_tfidf.tocsc())

print "Xgb, WordLevel TF-IDF: ", accuracy

# Xgboost с функциями в виде векторов TF-IDF уровня части речи

accuracy = train_model(xgboost.XGBClassifier(), xtrain_tfidf_ngram_chars.tocsc(), train_y, xvalid_tfidf_ngram_chars.tocsc())

print "Xgb, CharLevel Vectors: ", accuracy

# результат вывода

Xgb, Count Vectors:  0.6324

Xgb, WordLevel TF-IDF:  0.6364

Xgb, CharLevel Vectors:  0.6548

3.6 Неглубокие нейронные сети

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

https://www.analyticsvidhya.com/blog/2017/05/neural-network-from-scratch-in-python-and-r/

def create_model_architecture(input_size):

# create input layer

input_layer = layers.Input((input_size, ), sparse=True)

# create hidden layer

hidden_layer = layers.Dense(100, activation="relu")(input_layer)

# create output layer

output_layer = layers.Dense(1, activation="sigmoid")(hidden_layer)

classifier = models.Model(inputs = input_layer, outputs = output_layer)

classifier.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')

return classifier

classifier = create_model_architecture(xtrain_tfidf_ngram.shape[1])

accuracy = train_model(classifier, xtrain_tfidf_ngram, train_y, xvalid_tfidf_ngram, is_neural_net=True)

print "NN, Ngram Level TF IDF Vectors",  accuracy

#результат вывода:

Epoch 1/1

7500/7500 [==============================] - 1s 67us/step - loss: 0.6909

NN, Ngram Level TF IDF Vectors 0.5296

3.7 Глубокие нейронные сети

Глубокие нейронные сети — это более сложные нейронные сети, в которых скрытые слои выполняют более сложные операции, чем простые функции активации Sigmoid или Relu. Различные типы моделей глубокого обучения могут применяться к задачам классификации текста.

  • Сверточная нейронная сеть

В сверточной нейронной сети свертка на входном слое используется для вычисления выходных данных. В результате локального соединения каждая входная единица связана с выходным нейроном. Каждый уровень сети применяет различные фильтры и объединяет их результаты.

Чтобы узнать больше о сверточных нейронных сетях, посетите:

https://www.analyticsvidhya.com/blog/2017/06/architecture-of-convolutional-neural-networks-simplified-demystified/

def create_cnn():

# Add an Input Layer

input_layer = layers.Input((70, ))

# Add the word embedding Layer

embedding_layer = layers.Embedding(len(word_index) + 1, 300, weights=[embedding_matrix], trainable=False)(input_layer)

embedding_layer = layers.SpatialDropout1D(0.3)(embedding_layer)

# Add the convolutional Layer

conv_layer = layers.Convolution1D(100, 3, activation="relu")(embedding_layer)

# Add the pooling Layer

pooling_layer = layers.GlobalMaxPool1D()(conv_layer)

# Add the output Layers

output_layer1 = layers.Dense(50, activation="relu")(pooling_layer)

output_layer1 = layers.Dropout(0.25)(output_layer1)

output_layer2 = layers.Dense(1, activation="sigmoid")(output_layer1)

# Compile the model

model = models.Model(inputs=input_layer, outputs=output_layer2)

model.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')

return model

classifier = create_cnn()

accuracy = train_model(classifier, train_seq_x, train_y, valid_seq_x, is_neural_net=True)

print "CNN, Word Embeddings",  accuracy

# результат вывода

Epoch 1/1

7500/7500 [==============================] - 12s 2ms/step - loss: 0.5847

CNN, Word Embeddings 0.5296

  • Рекуррентная нейронная сеть — LSTM

В отличие от нейронных сетей с прямой связью, где выход активации нейронной сети с прямой связью распространяется только в одном направлении, выход активации рекуррентной нейронной сети распространяется в обоих направлениях (от входа к выходу и от выхода к входу). Таким образом, в архитектуре нейронной сети создаются петли, действующие как «состояние памяти» нейрона, которое позволяет нейрону вспомнить, что он уже выучил. Состояния памяти в RNN превосходят традиционные нейронные сети, но из-за этой архитектуры также возникает проблема, называемая градиентной дисперсией. Эта проблема затрудняет изучение и настройку параметров предыдущих слоев сети, когда сеть имеет много слоев. Для решения этой проблемы был разработан новый тип RNN, называемый моделью LSTM (Long Short Term Memory):

Чтобы узнать больше о LSTM, посетите:

https://www.analyticsvidhya.com/blog/2017/12/fundamentals-of-deep-learning-introduction-to-lstm/

def create_rnn_lstm():

# Add an Input Layer

input_layer = layers.Input((70, ))

# Add the word embedding Layer

embedding_layer = layers.Embedding(len(word_index) + 1, 300, weights=[embedding_matrix], trainable=False)(input_layer)

embedding_layer = layers.SpatialDropout1D(0.3)(embedding_layer)

# Add the LSTM Layer

lstm_layer = layers.LSTM(100)(embedding_layer)

# Add the output Layers

output_layer1 = layers.Dense(50, activation="relu")(lstm_layer)

output_layer1 = layers.Dropout(0.25)(output_layer1)

output_layer2 = layers.Dense(1, activation="sigmoid")(output_layer1)

# Compile the model

model = models.Model(inputs=input_layer, outputs=output_layer2)

model.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')

return model

classifier = create_rnn_lstm()

accuracy = train_model(classifier, train_seq_x, train_y, valid_seq_x, is_neural_net=True)

print "RNN-LSTM, Word Embeddings",  accuracy

# результат вывода

Epoch 1/1

7500/7500 [==============================] - 22s 3ms/step - loss: 0.6899

RNN-LSTM, Word Embeddings 0.5124

  • Рекуррентная нейронная сеть — ГРУ

Gated recurent unit — это еще одна форма рекуррентной нейронной сети, мы добавляем в сеть слой GRU вместо LSTM.

defcreate_rnn_gru():

# Add an Input Layer

input_layer = layers.Input((70, ))

# Add the word embedding Layer

embedding_layer = layers.Embedding(len(word_index) + 1, 300, weights=[embedding_matrix], trainable=False)(input_layer)

embedding_layer = layers.SpatialDropout1D(0.3)(embedding_layer)

# Add the GRU Layer

lstm_layer = layers.GRU(100)(embedding_layer)

# Add the output Layers

output_layer1 = layers.Dense(50, activation="relu")(lstm_layer)

output_layer1 = layers.Dropout(0.25)(output_layer1)

output_layer2 = layers.Dense(1, activation="sigmoid")(output_layer1)

# Compile the model

model = models.Model(inputs=input_layer, outputs=output_layer2)

model.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')

return model

classifier = create_rnn_gru()

accuracy = train_model(classifier, train_seq_x, train_y, valid_seq_x, is_neural_net=True)

print "RNN-GRU, Word Embeddings",  accuracy

# результат вывода

Epoch 1/1

7500/7500 [==============================] - 19s 3ms/step - loss: 0.6898

RNN-GRU, Word Embeddings 0.5124

  • Двунаправленный RNN

Уровень RNN также может быть инкапсулирован в двунаправленный уровень, мы инкапсулируем уровень GRU в двунаправленную сеть RNN.

defcreate_bidirectional_rnn():

# Add an Input Layer

input_layer = layers.Input((70, ))

# Add the word embedding Layer

embedding_layer = layers.Embedding(len(word_index) + 1, 300, weights=[embedding_matrix], trainable=False)(input_layer)

embedding_layer = layers.SpatialDropout1D(0.3)(embedding_layer)

# Add the LSTM Layer

lstm_layer = layers.Bidirectional(layers.GRU(100))(embedding_layer)

# Add the output Layers

output_layer1 = layers.Dense(50, activation="relu")(lstm_layer)

output_layer1 = layers.Dropout(0.25)(output_layer1)

output_layer2 = layers.Dense(1, activation="sigmoid")(output_layer1)

# Compile the model

model = models.Model(inputs=input_layer, outputs=output_layer2)

model.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')

return model

classifier = create_bidirectional_rnn()

accuracy = train_model(classifier, train_seq_x, train_y, valid_seq_x, is_neural_net=True)

print "RNN-Bidirectional, Word Embeddings",  accuracy

# результат вывода

Epoch 1/1

7500/7500 [==============================] - 32s 4ms/step - loss: 0.6889

RNN-Bidirectional, Word Embeddings 0.5124

  • Рекуррентная сверточная нейронная сеть

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

  • Иерархическая сеть внимания (последовательность моделей с вниманием)

  • seq2seq с механизмом внимания (Модели последовательностей с вниманием)

  • Двунаправленная рекуррентная сверточная нейронная сеть

  • CNN и RNN с большим количеством слоев

defcreate_rcnn():

# Add an Input Layer

input_layer = layers.Input((70, ))

# Add the word embedding Layer

embedding_layer = layers.Embedding(len(word_index) + 1, 300, weights=[embedding_matrix], trainable=False)(input_layer)

embedding_layer = layers.SpatialDropout1D(0.3)(embedding_layer)

# Add the recurrent layer

rnn_layer = layers.Bidirectional(layers.GRU(50, return_sequences=True))(embedding_layer)

# Add the convolutional Layer

conv_layer = layers.Convolution1D(100, 3, activation="relu")(embedding_layer)

# Add the pooling Layer

pooling_layer = layers.GlobalMaxPool1D()(conv_layer)

# Add the output Layers

output_layer1 = layers.Dense(50, activation="relu")(pooling_layer)

output_layer1 = layers.Dropout(0.25)(output_layer1)

output_layer2 = layers.Dense(1, activation="sigmoid")(output_layer1)

# Compile the model

model = models.Model(inputs=input_layer, outputs=output_layer2)

model.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')

return model

classifier = create_rcnn()

accuracy = train_model(classifier, train_seq_x, train_y, valid_seq_x, is_neural_net=True)

print "CNN, Word Embeddings",  accuracy

# результат вывода

Epoch 1/1

7500/7500 [==============================] - 11s 1ms/step - loss: 0.6902

CNN, Word Embeddings 0.5124

Дальнейшее повышение производительности моделей классификации текста

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

1. Очистите текст:Очистка текста помогает уменьшить шум в текстовых данных, включая стоп-слова, пунктуацию, изменения суффиксов и многое другое. Эта статья поможет понять, как реализовать классификацию текста:

https://www.analyticsvidhya.com/blog/2014/11/text-data-cleaning-steps-python/

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

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

3. Интегрированная модель:Объединение разных моделей и смешивание их выходных данных помогает еще больше улучшить результаты. Чтобы узнать больше об интеграции моделей, посетите:

https://www.analyticsvidhya.com/blog/2015/08/introduction-ensemble-learning/

напиши в конце

В этой статье обсуждается, как подготовить набор текстовых данных, например, очистить, создать наборы для обучения и проверки. Используйте различные виды разработки функций, такие как векторы счета, TF-IDF, встраивания слов, тематические модели и основные функции текста. Затем были обучены различные классификаторы, в том числе наивный байесовский алгоритм, логистическая регрессия, SVM, MLP, LSTM и GRU. Наконец, обсуждаются различные подходы к повышению производительности текстовых классификаторов.

Вы получили пользу от этой статьи? Поделитесь своими взглядами и мнениями в комментариях ниже.

Исходная ссылка: https://www.analyticsvidhya.com/blog/2018/04/a-comprehensive-guide-to-understand-and-implement-text-classification-in-python/

Профиль переводчика

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

Информация о наборе команды переводчиков

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

Вы можете получить:Регулярные тренинги по переводу повышают уровень перевода добровольцев и улучшают их осведомленность о границах науки о данных.Зарубежные друзья могут поддерживать связь с разработкой отечественных технологических приложений.Производственный, образовательный и исследовательский опыт THU Data School дает хорошие возможности для развития волонтеры.

Другие преимущества:Вашими партнерами в команде переводчиков станут специалисты по обработке данных из известных компаний, студенты Пекинского университета, Университета Цинхуа и известных зарубежных университетов.

Нажмите «Прочитать исходный текст» в конце статьи, чтобы присоединиться к команде данных~

Уведомление о перепечатке

Если вам нужно перепечатать, пожалуйста, укажите автора и источник на видном месте в начале статьи (от: Datapi ID: datapi) и поместите привлекательный QR-код datapi в конце статьи. Если есть оригинальная идентифицированная статья, отправьте [название статьи — имя и идентификатор официальной учетной записи для авторизации] на контактный адрес электронной почты, подайте заявку на авторизацию в белом списке и отредактируйте ее по мере необходимости.

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

нажмите«Прочитай исходный текст»Примите организацию

Категории