Это 20-я статья в моей серии статей по Python для НЛП. В последних нескольких статьях мы изучали методы глубокого обучения для выполнения различных задач машинного обучения, и вы также должны быть знакомы с концепцией встраивания слов. Встраивание слов-это способ преобразования текстовой информации в числовую форму, которая, в свою очередь, может быть использована в качестве входных данных для статистических алгоритмов. В моей статье о встраиваниях слов я объяснил , как мы можем создавать наши собственные встраивания слов и как мы можем использовать встроенные встраивания слов, такие как Перчатка .
В этой статье мы рассмотрим Fast Text , который является еще одним чрезвычайно полезным модулем для встраивания слов и классификации текста. Fast Text был разработан Facebook и показал отличные результаты по многим проблемам НЛП, таким как обнаружение семантического сходства и классификация текста.
В этой статье мы кратко рассмотрим библиотеку быстрого текста. Эта статья разделена на два раздела. В первом разделе мы увидим, как быстро Текстовая библиотека создает векторные представления, которые можно использовать для поиска семантических сходств между словами. Во втором разделе мы рассмотрим применение быстрой текстовой библиотеки для классификации текста.
Быстрый текст для семантического сходства
Быстрый текст поддерживает как Непрерывный пакет слов, так и модели Skip-Gram . В этой статье мы реализуем модель skip-gram для изучения векторного представления слов из статей Википедии об искусственном интеллекте , машинном обучении , глубоком обучении и нейронных сетях . Поскольку эти темы очень похожи, мы выбрали эти темы, чтобы иметь значительный объем данных для создания корпуса. Вы можете добавить больше тем аналогичного характера, если хотите.
В качестве первого шага нам нужно импортировать необходимые библиотеки. Мы будем использовать библиотеку Википедии для Python , которую можно загрузить с помощью следующей команды:
$ pip install wikipedia
Импорт библиотек
Следующий скрипт импортирует необходимые библиотеки в наше приложение:
from keras.preprocessing.text import Tokenizer
from gensim.models.fasttext import FastText
import numpy as np
import matplotlib.pyplot as plt
import nltk
from string import punctuation
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer
from nltk.tokenize import sent_tokenize
from nltk import WordPunctTokenizer
import wikipedia
import nltk
nltk.download('punkt')
nltk.download('wordnet')
nltk.download('stopwords')
en_stop = set(nltk.corpus.stopwords.words('english'))
%matplotlib inline
Вы можете видеть, что мы используем модуль Fast Text из gensim.models.быстрый текст библиотека. Для представления слов и семантического сходства мы можем использовать модель Gensim для быстрого текста. Эта модель может работать на Windows, однако для классификации текста нам придется использовать платформу Linux. Мы увидим это в следующем разделе.
Выскабливание Статей Википедии
На этом этапе мы соскребем необходимые статьи Википедии. Посмотрите на сценарий ниже:
artificial_intelligence = wikipedia.page("Artificial Intelligence").content
machine_learning = wikipedia.page("Machine Learning").content
deep_learning = wikipedia.page("Deep Learning").content
neural_network = wikipedia.page("Neural Network").content
artificial_intelligence = sent_tokenize(artificial_intelligence)
machine_learning = sent_tokenize(machine_learning)
deep_learning = sent_tokenize(deep_learning)
neural_network = sent_tokenize(neural_network)
artificial_intelligence.extend(machine_learning)
artificial_intelligence.extend(deep_learning)
artificial_intelligence.extend(neural_network)
Чтобы очистить страницу Википедии, мы можем использовать метод page из модуля wikipedia . Имя страницы, которую вы хотите удалить, передается в качестве параметра методу page . Метод возвращает объект Wikipedia Page , который затем можно использовать для извлечения содержимого страницы с помощью атрибута content , как показано в приведенном выше скрипте.
Соскобленное содержимое с четырех страниц Википедии затем маркируется в предложения с помощью метода sent_tokenize . Метод sent_tokenize возвращает список предложений. Предложения для четырех страниц маркируются отдельно. Наконец, предложения из четырех статей соединяются вместе с помощью метода extend .
Предварительная обработка данных
Следующий шаг-очистить наши текстовые данные, удалив знаки препинания и цифры. Мы также преобразуем данные в нижний регистр. Слова в наших данных будут лемматизированы до их корневой формы. Кроме того, стоп-слова и слова длиной менее 4 будут удалены из корпуса.
Функция preprocess_text , как определено ниже, выполняет задачи предварительной обработки.
import re
from nltk.stem import WordNetLemmatizer
stemmer = WordNetLemmatizer()
def preprocess_text(document):
# Remove all the special characters
document = re.sub(r'\W', ' ', str(document))
# remove all single characters
document = re.sub(r'\s+[a-zA-Z]\s+', ' ', document)
# Remove single characters from the start
document = re.sub(r'\^[a-zA-Z]\s+', ' ', document)
# Substituting multiple spaces with single space
document = re.sub(r'\s+', ' ', document, flags=re.I)
# Removing prefixed 'b'
document = re.sub(r'^b\s+', '', document)
# Converting to Lowercase
document = document.lower()
# Lemmatization
tokens = document.split()
tokens = [stemmer.lemmatize(word) for word in tokens]
tokens = [word for word in tokens if word not in en_stop]
tokens = [word for word in tokens if len(word) > 3]
preprocessed_text = ' '.join(tokens)
return preprocessed_text
Давайте посмотрим, выполняет ли наша функция желаемую задачу, предварительно обработав фиктивное предложение:
sent = preprocess_text("Artificial intelligence, is the most advanced technology of the present era")
print(sent)
final_corpus = [preprocess_text(sentence) for sentence in artificial_intelligence if sentence.strip() !='']
word_punctuation_tokenizer = nltk.WordPunctTokenizer()
word_tokenized_corpus = [word_punctuation_tokenizer.tokenize(sent) for sent in final_corpus]
Предварительно обработанное предложение выглядит следующим образом:
artificial intelligence advanced technology present
Вы можете видеть, что знаки препинания и стоп-слова были удалены, а предложения были лемматизированы. Кроме того, были также удалены слова длиной менее 4, такие как “эра”. Эти варианты были выбраны случайным образом для данного теста, поэтому вы можете разрешить слова с меньшей или большей длиной в корпусе.
Создание Представления Слов
Мы предварительно обработали наш корпус. Сейчас самое время создавать словесные представления с помощью FastText. Давайте сначала определим гиперпараметры для нашей быстрой текстовой модели:
embedding_size = 60 window_size = 40 min_word = 5 down_sampling = 1e-2
Здесь embedding_size – это размер вектора вложения. Другими словами, каждое слово в нашем корпусе будет представлено в виде 60-мерного вектора. window_size – это размер числа слов, встречающихся до и после слова, на основе которого будут изучены представления слов для этого слова. Это может показаться сложным, однако в модели skip-gram мы вводим слово в алгоритм, а на выходе получаем контекстные слова. Если размер окна равен 40, то для каждого входа будет 80 выходов: 40 слов, которые встречаются перед входным словом, и 40 слов, которые встречаются после входного слова. Вложения слов для входного слова изучаются с использованием этих 80 выходных слов.
Следующим гиперпараметром является main_word , который определяет минимальную частоту слова в корпусе, для которого будут генерироваться представления слов. Наконец, наиболее часто встречающееся слово будет уменьшено на число, указанное атрибутом down_sampling .
Теперь давайте создадим нашу Быструю текстовую модель для представления слов.
%%time
ft_model = FastText(word_tokenized_corpus,
size=embedding_size,
window=window_size,
min_count=min_word,
sample=down_sampling,
sg=1,
iter=100)
Все параметры в приведенном выше скрипте объясняются сами собой, за исключением sg . Параметр sg определяет тип модели, которую мы хотим создать. Значение 1 указывает, что мы хотим создать модель skip-gram. В то время как ноль указывает модель мешка слов, которая также является значением по умолчанию.
Выполните описанный выше сценарий. Это может занять некоторое время. На моей машине статистика времени выполнения приведенного выше кода выглядит следующим образом:
CPU times: user 1min 45s, sys: 434 ms, total: 1min 45s Wall time: 57.2 s
Давайте теперь посмотрим на слово представление для слова “искусственный”. Для этого вы можете использовать метод wv объекта Fast Text и передать ему имя слова внутри списка.
print(ft_model.wv['artificial'])
Вот результат:
[-3.7653010e-02 -4.5558015e-01 3.2035065e-01 -1.5289043e-01 4.0645871e-02 -1.8946664e-01 7.0426887e-01 2.8806925e-01 -1.8166199e-01 1.7566417e-01 1.1522485e-01 -3.6525184e-01 -6.4378887e-01 -1.6650060e-01 7.4625671e-01 -4.8166099e-01 2.0884991e-01 1.8067230e-01 -6.2647951e-01 2.7614883e-01 -3.6478557e-02 1.4782918e-02 -3.3124462e-01 1.9372456e-01 4.3028224e-02 -8.2326338e-02 1.0356739e-01 4.0792203e-01 -2.0596240e-02 -3.5974573e-02 9.9928051e-02 1.7191900e-01 -2.1196717e-01 6.4424530e-02 -4.4705093e-02 9.7391091e-02 -2.8846195e-01 8.8607501e-03 1.6520244e-01 -3.6626378e-01 -6.2017748e-04 -1.5083785e-01 -1.7499258e-01 7.1994811e-02 -1.9868813e-01 -3.1733567e-01 1.9832127e-01 1.2799081e-01 -7.6522082e-01 5.2335665e-02 -4.5766738e-01 -2.7947658e-01 3.7890410e-03 -3.8761377e-01 -9.3001537e-02 -1.7128626e-01 -1.2923178e-01 3.9627206e-01 -3.6673656e-01 2.2755004e-01]
В выходных данных выше вы можете увидеть 60-мерный вектор для слова “искусственный”
Давайте теперь найдем топ-5 наиболее похожих слов для слов “искусственный”, “интеллект”, “машина”, “сеть”, “рекуррентный”, “глубокий”. Вы можете выбрать любое количество слов. Следующий скрипт печатает указанные слова вместе с 5 наиболее похожими словами.
semantically_similar_words = {words: [item[0] for item in ft_model.wv.most_similar([words], topn=5)]
for words in ['artificial', 'intelligence', 'machine', 'network', 'recurrent', 'deep']}
for k,v in semantically_similar_words.items():
print(k+":"+str(v))
Результат выглядит следующим образом:
artificial:['intelligence', 'inspired', 'book', 'academic', 'biological'] intelligence:['artificial', 'human', 'people', 'intelligent', 'general'] machine:['ethic', 'learning', 'concerned', 'argument', 'intelligence'] network:['neural', 'forward', 'deep', 'backpropagation', 'hidden'] recurrent:['rnns', 'short', 'schmidhuber', 'shown', 'feedforward'] deep:['convolutional', 'speech', 'network', 'generative', 'neural']
Мы также можем найти косинусное сходство между векторами для любых двух слов, как показано ниже:
print(ft_model.wv.similarity(w1='artificial', w2='intelligence'))
На выходе отображается значение “0.7481”. Значение может быть где угодно между 0 и 1. Более высокое значение означает более высокое сходство.
Визуализация Сходства Слов
Хотя каждое слово в нашей модели представлено в виде 60-мерного вектора, мы можем использовать метод анализа главных компонент, чтобы найти два главных компонента. Затем два главных компонента могут быть использованы для построения слов в двумерном пространстве. Однако сначала нам нужно создать список всех слов в словаре semantically_similar_words . Это делает следующий сценарий:
from sklearn.decomposition import PCA all_similar_words = sum([[k] + v for k, v in semantically_similar_words.items()], []) print(all_similar_words) print(type(all_similar_words)) print(len(all_similar_words))
В приведенном выше сценарии мы перебираем все пары ключ-значение в словаре semantically_similar_words . Каждый ключ в словаре-это слово. Соответствующее значение представляет собой список всех семантически сходных слов. Поскольку мы нашли топ-5 наиболее похожих слов для списка из 6 слов, то есть “искусственный”, “интеллект”, “машина”, “сеть”, “рекуррентный”, “глубокий”, вы увидите, что в списке all_similar_words будет 30 элементов.
Затем мы должны найти векторы слов для всех этих 30 слов, а затем использовать PCA, чтобы уменьшить размеры векторов слов с 60 до 2. Затем мы можем использовать метод plt , который является псевдонимом метода matplotlib.pyplot для построения слов в двумерном векторном пространстве.
Выполните следующий сценарий, чтобы визуализировать слова:
word_vectors = ft_model.wv[all_similar_words]
pca = PCA(n_components=2)
p_comps = pca.fit_transform(word_vectors)
word_names = all_similar_words
plt.figure(figsize=(18, 10))
plt.scatter(p_comps[:, 0], p_comps[:, 1], c='red')
for word_names, x, y in zip(word_names, p_comps[:, 0], p_comps[:, 1]):
plt.annotate(word_names, xy=(x+0.06, y+0.03), xytext=(0, 0), textcoords='offset points')
Вывод вышеприведенного скрипта выглядит следующим образом:
Вы можете видеть, что слова, которые часто встречаются вместе в тексте, также близки друг к другу в двумерной плоскости. Например, слова “глубокий” и “сетевой” почти совпадают. Точно так же слова “прямая связь” и “обратное распространение” также очень близки.
Теперь мы знаем, как создавать вложения слов с помощью FastText. В следующем разделе мы увидим, как быстро текст может быть использован для задач классификации текста.
Быстрый текст для классификации текста
Классификация текста относится к классификации текстовых данных по заранее определенным категориям на основе содержания текста. Анализ настроений, обнаружение спама и обнаружение тегов-вот некоторые из наиболее распространенных примеров использования вариантов классификации текста.
Модуль быстрой классификации текста может быть запущен только через Linux или OSX. Если вы являетесь пользователем Windows, вы можете использовать Google Colaboratory для запуска модуля быстрой классификации текста. Все сценарии в этом разделе были запущены с помощью Google Collaboratory.
Набор данных
Набор данных для этой статьи можно скачать по ссылке Kaggle . Набор данных содержит несколько файлов, но нас интересует только файл yelp_review.csv . Файл содержит более 5,2 миллиона отзывов о различных предприятиях, включая рестораны, бары, стоматологов, врачей, салоны красоты и т. Д. Однако мы будем использовать только первые 50 000 записей для обучения нашей модели из-за ограничений памяти. Вы можете попробовать с большим количеством записей, если хотите.
Давайте импортируем необходимые библиотеки и загрузим набор данных:
import pandas as pd
import numpy as np
yelp_reviews = pd.read_csv("/content/drive/My Drive/Colab Datasets/yelp_review_short.csv")
bins = [0,2,5]
review_names = ['negative', 'positive']
yelp_reviews['reviews_score'] = pd.cut(yelp_reviews['stars'], bins, labels=review_names)
yelp_reviews.head()
В приведенном выше скрипте мы загружаем файл yelp_review_short.csv , содержащий 50 000 отзывов, с функцией pd.read_csv .
Мы упростим нашу задачу, преобразовав числовые значения для обзоров в категориальные. Это будет сделано путем добавления нового столбца reviews_score в наш набор данных. Если отзыв пользователя имеет значение между 1-2 в столбце Stars (который оценивает бизнес по шкале 1-5), то столбец reviews_score будет иметь строковое значение negative . Если рейтинг находится в диапазоне 3-5 в столбце Stars , то столбец reviews_score будет содержать значение positive . Это делает нашу проблему проблемой бинарной классификации.
Наконец заголовок фрейма данных печатается как показано ниже:
Установка Быстрого текста
Следующим шагом является импорт моделей FastText, которые можно импортировать с помощью команды wget из репозитория GitHub, как показано в следующем скрипте:
!wget https://github.com/facebookresearch/fastText/archive/v0.1.0.zip
Примечание : Если вы выполняете приведенную выше команду из терминала Linux, вам не нужно добавлять префикс ! перед приведенной выше командой. В Google Collaboratory notebook любая команда после ! выполняется как команда оболочки, а не в интерпретаторе Python. Следовательно, все команды, не относящиеся к Python, здесь имеют префикс ! .
Если вы запустите приведенный выше скрипт и увидите следующие результаты, это означает, что Быстрый текст был успешно загружен:
--2019-08-16 15:05:05-- https://github.com/facebookresearch/fastText/archive/v0.1.0.zip Resolving github.com (github.com)... 140.82.113.4 Connecting to github.com (github.com)|140.82.113.4|:443... connected. HTTP request sent, awaiting response... 302 Found Location: https://codeload.github.com/facebookresearch/fastText/zip/v0.1.0 [following] --2019-08-16 15:05:05-- https://codeload.github.com/facebookresearch/fastText/zip/v0.1.0 Resolving codeload.github.com (codeload.github.com)... 192.30.255.121 Connecting to codeload.github.com (codeload.github.com)|192.30.255.121|:443... connected. HTTP request sent, awaiting response... 200 OK Length: unspecified [application/zip] Saving to: 'v0.1.0.zip' v0.1.0.zip [ <=> ] 92.06K --.-KB/s in 0.03s 2019-08-16 15:05:05 (3.26 MB/s) - 'v0.1.0.zip' saved [94267]
Следующий шаг-распаковать быстрые текстовые модули. Просто введите следующую команду:
!unzip v0.1.0.zip
Далее вам нужно перейти в каталог, в который вы загрузили Быстрый текст, а затем выполнить команду !make команда для запуска двоичных файлов C++. Выполните следующие действия:
cd fastText-0.1.0 !make
Если вы видите следующий вывод, это означает, что Fast Text успешно установлен на вашем компьютере.
c++ -pthread -std=c++0x -O3 -funroll-loops -c src/args.cc c++ -pthread -std=c++0x -O3 -funroll-loops -c src/dictionary.cc c++ -pthread -std=c++0x -O3 -funroll-loops -c src/productquantizer.cc c++ -pthread -std=c++0x -O3 -funroll-loops -c src/matrix.cc c++ -pthread -std=c++0x -O3 -funroll-loops -c src/qmatrix.cc c++ -pthread -std=c++0x -O3 -funroll-loops -c src/vector.cc c++ -pthread -std=c++0x -O3 -funroll-loops -c src/model.cc c++ -pthread -std=c++0x -O3 -funroll-loops -c src/utils.cc c++ -pthread -std=c++0x -O3 -funroll-loops -c src/fasttext.cc c++ -pthread -std=c++0x -O3 -funroll-loops args.o dictionary.o productquantizer.o matrix.o qmatrix.o vector.o model.o utils.o fasttext.o src/main.cc -o fasttext
Чтобы проверить установку, выполните следующую команду:
!./fasttext
Вы должны видеть, что эти команды поддерживаются быстрым текстом:
usage: fasttextThe commands supported by FastText are: supervised train a supervised classifier quantize quantize a model to reduce the memory usage test evaluate a supervised classifier predict predict most likely labels predict-prob predict most likely labels with probabilities skipgram train a skipgram model cbow train a cbow model print-word-vectors print word vectors given a trained model print-sentence-vectors print sentence vectors given a trained model nn query for nearest neighbors analogies query for analogies
Классификация текста
Прежде чем мы обучим модели быстрого текста выполнять классификацию текста, уместно упомянуть, что FastText принимает данные в специальном формате, который выглядит следующим образом:
_label_tag This is sentence 1 _label_tag2 This is sentence 2.
Если мы посмотрим на наш набор данных, он не находится в желаемом формате. Текст с позитивным настроем должен выглядеть так:
__label__positive burgers are very big portions here.
Точно так же и негативные отзывы должны выглядеть так:
__label__negative They do not use organic ingredients, but I thi...
Следующий скрипт фильтрует столбцы reviews_score и text из набора данных, а затем префиксы __label__ перед всеми значениями в столбце reviews_score . Аналогично, \n и \t заменяются пробелом в столбце text . Наконец, обновленный фрейм данных записывается на диск в виде yelp_reviews_updated.txt .
import pandas as pd
from io import StringIO
import csv
col = ['reviews_score', 'text']
yelp_reviews = yelp_reviews[col]
yelp_reviews['reviews_score']=['__label__'+ s for s in yelp_reviews['reviews_score']]
yelp_reviews['text']= yelp_reviews['text'].replace('\n',' ', regex=True).replace('\t',' ', regex=True)
yelp_reviews.to_csv(r'/content/drive/My Drive/Colab Datasets/yelp_reviews_updated.txt', index=False, sep=' ', header=False, quoting=csv.QUOTE_NONE, quotechar="", escapechar=" ")
Теперь давайте напечатаем заголовок обновленного фрейма данных yelp_reviews .
yelp_reviews.head()
Вы должны увидеть следующие результаты:
reviews_score text 0 __label__positive Super simple place but amazing nonetheless. It... 1 __label__positive Small unassuming place that changes their menu... 2 __label__positive Lester's is located in a beautiful neighborhoo... 3 __label__positive Love coming here. Yes the place always needs t... 4 __label__positive Had their chocolate almond croissant and it wa...
Аналогично, хвост фрейма данных выглядит следующим образом:
reviews_score text 49995 __label__positive This is an awesome consignment store! They hav... 49996 __label__positive Awesome laid back atmosphere with made-to-orde... 49997 __label__positive Today was my first appointment and I can hones... 49998 __label__positive I love this chic salon. They use the best prod... 49999 __label__positive This place is delicious. All their meats and s...
Мы преобразовали наш набор данных в требуемую форму. Следующий шаг-разделить наши данные на обучающие и тестовые наборы. 80% данных, то есть первые 40 000 записей из 50 000 записей, будут использоваться для обучения данных, в то время как 20% данных (последние 10 000 записей) будут использоваться для оценки производительности алгоритма.
Следующий сценарий делит данные на обучающие и тестовые наборы:
!head -n 40000 "/content/drive/My Drive/Colab Datasets/yelp_reviews_updated.txt" > "/content/drive/My Drive/Colab Datasets/yelp_reviews_train.txt" !tail -n 10000 "/content/drive/My Drive/Colab Datasets/yelp_reviews_updated.txt" > "/content/drive/My Drive/Colab Datasets/yelp_reviews_test.txt"
Как только приведенный выше сценарий будет выполнен, yelp_reviews_train.txt будет сгенерирован файл, содержащий обучающие данные. Аналогично, вновь сгенерированный yelp_reviews_test.txt файл будет содержать тестовые данные.
Сейчас самое время тренировать свой быстрый алгоритм классификации текста.
%%time !./fasttext supervised -input "/content/drive/My Drive/Colab Datasets/yelp_reviews_train.txt" -output model_yelp_reviews
Для обучения алгоритма мы должны использовать команду supervised и передать ей входной файл. Имя модели указывается после ключевого слова -output . Приведенный выше сценарий приведет к созданию обученной модели классификации текста с именем model_yelp_reviews.bin . Вот вывод для приведенного выше скрипта:
Read 4M words Number of words: 177864 Number of labels: 2 Progress: 100.0% words/sec/thread: 2548017 lr: 0.000000 loss: 0.246120 eta: 0h0m CPU times: user 212 ms, sys: 48.6 ms, total: 261 ms Wall time: 15.6 s
Вы можете взглянуть на модель с помощью команды !ls , как показано ниже:
!ls
Вот результат:
args.o Makefile quantization-results.sh classification-example.sh matrix.o README.md classification-results.sh model.o src CONTRIBUTING.md model_yelp_reviews.bin tutorials dictionary.o model_yelp_reviews.vec utils.o eval.py PATENTS vector.o fasttext pretrained-vectors.md wikifil.pl fasttext.o productquantizer.o word-vector-example.sh get-wikimedia.sh qmatrix.o yelp_reviews_train.txt LICENSE quantization-example.sh
Вы можете увидеть файл model_yelp_reviews.bin в приведенном выше списке документов.
Наконец, для тестирования модели можно использовать команду test . Вы должны указать имя модели и тестовый файл после команды test , как показано ниже:
!./fasttext test model_yelp_reviews.bin "/content/drive/My Drive/Colab Datasets/yelp_reviews_test.txt"
Вывод вышеприведенного скрипта выглядит следующим образом:
N 10000 [email protected] 0.909 [email protected] 0.909 Number of examples: 10000
Здесь [email protected] относится к точности и [email protected] относится к отзыву. Вы можете видеть, что наша модель достигает точности и отзыва 0,909, что довольно хорошо.
Давайте теперь попробуем очистить наш текст от знаков препинания, специальных символов и преобразовать его в нижний регистр, чтобы улучшить однородность текста. Следующий сценарий очищает набор поездов:
!cat "/content/drive/My Drive/Colab Datasets/yelp_reviews_train.txt" | sed -e "s/\([.\!?,'/()]\)/ \1 /g" | tr "[:upper:]" "[:lower:]" > "/content/drive/My Drive/Colab Datasets/yelp_reviews_train_clean.txt"
И следующий сценарий очищает тестовый набор:
"/content/drive/My Drive/Colab Datasets/yelp_reviews_test.txt" | sed -e "s/\([.\!?,'/()]\)/ \1 /g" | tr "[:upper:]" "[:lower:]" > "/content/drive/My Drive/Colab Datasets/yelp_reviews_test_clean.txt"
Теперь мы будем тренировать модель на очищенном тренировочном наборе:
%%time !./fasttext supervised -input "/content/drive/My Drive/Colab Datasets/yelp_reviews_train_clean.txt" -output model_yelp_reviews
И, наконец, мы будем использовать модель, обученную на очищенном обучающем наборе, чтобы делать прогнозы на очищенном тестовом наборе:
!./fasttext test model_yelp_reviews.bin "/content/drive/My Drive/Colab Datasets/yelp_reviews_test_clean.txt"
Вывод вышеприведенного скрипта выглядит следующим образом:
N 10000 [email protected] 0.915 [email protected] 0.915 Number of examples: 10000
Вы можете видеть небольшое увеличение как точности, так и отзыва. Чтобы еще больше улучшить модель, вы можете увеличить эпохи и скорость обучения модели. Следующий сценарий устанавливает количество эпох равным 30, а скорость обучения-0,5.
%%time !./fasttext supervised -input "/content/drive/My Drive/Colab Datasets/yelp_reviews_train_clean.txt" -output model_yelp_reviews -epoch 30 -lr 0.5
Вы можете попробовать разные цифры и посмотреть, сможете ли вы получить лучшие результаты. Не забудьте поделиться своими результатами в комментариях!
Вывод
Быстрая текстовая модель недавно была доказана на современном уровне для встраивания слов и задач классификации текста во многих наборах данных. Он очень прост в использовании и молниеносен по сравнению с другими моделями встраивания слов.
В этой статье мы кратко рассмотрели, как найти семантическое сходство между различными словами, создавая вложения слов с помощью FastText. Вторая часть статьи объясняет, как выполнить классификацию текста с помощью быстрой текстовой библиотеки.