NLP: когда машины начинают понимать нас (Часть 3)

1. Введение

В предыдущих статьях мы рассмотрели теоретические основы NLP, включая базовые понятия, такие как токенизация, стемминг, лемматизация и другие. Мы также поработали с библиотеками NLTK и spaCy и выполнили простые задания по обработке текста.

В этой статье мы продолжим изучение NLP и перейдем к более продвинутым темам, которые являются главными для построения современных приложений и моделей в области обработки естественного языка. А также создадим и обучим модели самостоятельно, используя TensorFlow/Keras и PyTorch.

2. Векторные представления слов

Векторные представления слов позволяют нам преобразовывать слова в числовые векторы. Это существенно улучшает качество моделей NLP.

В данной статье мы рассмотрим:

1. Word2Vec

2. GloVe

3. FastText

4. Библиотеку Gensim

5. Примеры кода и задания

2.1 Word2Vec

Word2Vec — это группа моделей, которую разработала команда Google. Word2Vec преобразует слова в векторы определённой размерности, где схожие по смыслу слова имеют близкие векторные представления.

Архитектуры Word2Vec

Word2Vec представляет два основных метода обучения:

• Continuous Bag-of-Words (CBOW): предсказывает текущее слово по контексту (окружающим словам).

• Skip-Gram: предсказывает окружающие слова по текущему слову.

Особенности

• Эффективность: Быстро обучается на больших объёмах текстах.

• Качество: Учитывает семантические отношения между словами.

2.2 GloVe

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

Особенности

• Глобальная матрица соотношений — это способ увидеть, как слова связаны между собой в целом по всем текстам, проверяя, как часто они появляются вместе.

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

2.3 FastText

FastText — модель, разработанная Facebook AI Research. Она расширяет Word2Vec, учитывая морфологию слов.

Особенности

• Символьные n-граммы: Представляет слова как группу буквенных n-грамм.

• Преимущества: Лучше справляется с редкими словами и опечатками.

2.4 Реализация и применение с помощью Gensim

Gensim — это библиотека Python для для векторных представлений.

Установка Gensim

pip install gensim

2.5 Word2Vec с использованием Gensim

Для начала подготовим наши данные:

import gensim from gensim.models import Word2Vec from gensim.utils import simple_preprocess  texts = [     "Хабр — популярная платформа для IT специалистов",     "На Хабре можно найти статьи по программированию и технологиям",     "Пользователи Хабра делятся своим опытом и знаниями", ]  # Предобработка текстов sentences = [simple_preprocess(text) for text in texts]

Обучим нашу модель Word2Vec:

model = Word2Vec(     sentences=sentences,     vector_size=100,  # размерность текстов     window=5,         # размер контекстного окна     min_count=1,      # минимальную частоту слова     workers=4,        # количество потоков     sg=0              # использование Continuous Bag-of-Words )

Получение вектора слова:

vector = model.wv['хабр'] print("Вектор слова 'хабр':\n", vector)

Вывод:

Вектор слова 'хабр': [ 0.00973555 -0.00978038 -0.00649949 0.00278379 0.00643199 -0.00536737 0.00275249 0.00912131 -0.00681542 -0.00609991 -0.00498964 -0.00367641 0.00184972 0.00968263 0.00643778 0.00039709 0.00247077 0.00844049 0.00912898 0.00562875 0.00594626 -0.00762069 -0.00382767 -0.00568033 0.00618177 -0.00225645 -0.00877944 0.00761912 0.00839968 -0.00332024 0.00911666 -0.00073836 -0.00362652 -0.00038469 0.00019443 -0.0035049 0.00281324 0.00572971 0.00686901 -0.00890347 -0.00219273 -0.0054818 0.0075211 0.0065017 -0.00436072 0.00232683 -0.00595366 0.0002365 0.00946176 -0.00260984 -0.00518772 -0.00739721 -0.00291194 -0.00086431 0.00352786 0.00974189 -0.00338928 0.00190177 0.00968101 0.00153159 0.0009865 0.00980237 0.00929546 0.00770807 -0.00617053 0.00998399 0.00584899 0.00907267 -0.0019952 0.00334994 0.00683356 -0.00389376 0.00664285 0.00256286 0.00931373 -0.0030358 -0.00310937 0.00621539 -0.00907825 -0.00725399 -0.00650003 -0.00074907 -0.00236302 0.00681552 0.00923659 -0.00090976 0.00141282 0.00202036 -0.0020198 -0.00803434 0.00744105 -0.0042979 0.00457652 0.0090897 0.00304322 0.00313879 0.00406183 -0.00270122 0.00382477 0.00033762]

Поиск наиболее похожих слов:

similar_words = model.wv.most_similar('хабр') print("Слова, похожие на 'хабр':") for word, similarity in similar_words:     print(f"{word}: {similarity}")

Вывод:

Слова, похожие на 'хабр': можно: 0.15923377871513367 популярная: 0.1528114527463913 технологиям: 0.14256368577480316 статьи: 0.1326463520526886 своим: 0.1193675547838211 на: 0.07913301885128021 специалистов: 0.07480262219905853 делятся: 0.059599656611680984 по: 0.03546776622533798 для: 0.03307188302278519

2.5 FastText с использованием Gensim

Обучение модели:

from gensim.models import FastText  ft_model = FastText(     vector_size=100,     window=5,     min_count=1,     workers=4 )  ft_model.build_vocab(corpus_iterable=sentences)  ft_model.train(      corpus_iterable=sentences,     total_examples=len(sentences),     epochs=10 )

Поиск похожих слов:

similar_words_ft = ft_model.wv.most_similar('хабр') print("Слова, похожие на 'хабр':") for word, similarity in similar_words_ft:     print(f"{word}: {similarity:.3f}")

Вывод:

Слова, похожие на 'хабр': хабра: 0.514 хабре: 0.421 пользователи: 0.046 найти: 0.045 технологиям: 0.041 специалистов: 0.019 по: 0.016 делятся: 0.010 на: -0.002 статьи: -0.034

3. Классификация текста с помощью scikit-learn

Основные шаги класcификации текста:

1. Сбор данных

2. Предобработка данных

3. Преобразование текста в числовой формат

4. Обучение модели

5. Оценка модели

6. Применение модели

3.1 Работа с размеченными данными

Размеченные данные — это данные, где каждому экземпляру соответствует метка или категория.

Источники размеченных данных

• Многие наборы данных доступны в библиотеке sklearn.datasets или nltk.

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

3.2 Оценка качества моделей

Метрики оценки

• Точность (Accuracy): Показывает, какую долю всех предсказаний модель сделала правильно.

• Матрица ошибок (Confusion Matrix): Таблица, которая показывает, сколько раз модель правильно или неправильно предсказала каждый класс.

• Precision: Определяет сколько из всех примеров, которые модель предсказала как положительные, на самом деле положительные.

• Recall: Определяет, сколько из всех реальных положительных примеров, модель обнаружила.

• F1-score: Среднее значение между Precision и Recall.

Валидация моделей

• Тренировочные и тестовые данные: Разделение данных на обучающую и тестовую выборки.

• Кросс-валидация: Разделение данных на K подвыборок и обучение модели K раз.

3.3 Примеры кода

Классификация текстов новостей из 20 Newsgroups датасета

Этот набор данных представляет собой коллекцию документов группы новостей. 

Импорт библиотек:

import numpy as np from sklearn.datasets import fetch_20newsgroups from sklearn.model_selection import train_test_split from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer from sklearn.naive_bayes import MultinomialNB from sklearn.metrics import classification_report, confusion_matrix, accuracy_score

Загрузка данных:

categories = ['rec.sport.baseball', 'rec.sport.hockey', 'talk.politics.mideast', 'sci.space'] newsgroups = fetch_20newsgroups(subset='all', categories=categories)   X = newsgroups.data #тексты y = newsgroups.target #метки

Разделение на обучающую и тестовую выборки:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Преобразование текста в числовой формат:

tfidf_vectorizer = TfidfVectorizer(stop_words='english', lowercase=True) X_train_tfidf = tfidf_vectorizer.fit_transform(X_train) X_test_tfidf = tfidf_vectorizer.transform(X_test)

Обучение модели с использованием байесовского классификатора:

model = MultinomialNB() model.fit(X_train_tfidf, y_train)

Прогнозирование и оценка модели:

y_pred = model.predict(X_test_tfidf) # Прогнозирование на тестовой выборке  print("Accuracy:", accuracy_score(y_test, y_pred)) # Оценка точности  print(classification_report(y_test, y_pred, target_names=newsgroups.target_names))

Вывод:

Построение матрицы ошибок:

import matplotlib.pyplot as plt import seaborn as sns  cm = confusion_matrix(y_test, y_pred) sns.heatmap(cm, annot=True, fmt='d',             xticklabels=newsgroups.target_names,             yticklabels=newsgroups.target_names) plt.ylabel('Истинный класс') plt.xlabel('Предсказанный класс') plt.show()

Вывод:

4. Нейронные сети для NLP

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

Основные компоненты

• Входной слой: Получает данные.

• Скрытые слои: Обрабатывают эти данные, выявляя в них важные особенности.

• Выходной слой: Выдаёт результат — ответ или предсказание.

• Активирационные функции: Позволяют нейронной сети понимать и представлять сложные, нелинейные зависимости в данных.

• Функция потерь: Показывает, насколько хороша модель, сравнивая предсказания с реальными данными.

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

Процесс обучения

• Прямое распространение (forward propagation): Процесс, при котором входные данные проходят через нейронную сеть от входного слоя к выходному, чтобы сделать предсказание.

• Обратное распространение (backpropagation): Алгоритм обучения нейронной сети, при котором сеть корректирует свои веса, чтобы уменьшить ошибку между предсказанием и реальным ответом.

4.2 Рекуррентные нейронные сети (RNN)

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

Проблемы стандартных RNN

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

• Эффективность на коротких последовательностях: стандартные RNN хорошо работают с короткими последовательностями, но плохо на длинных.

4.3 LSTM и GRU

LSTM (Long Short-Term Memory) — это разновидность RNN, разработанная для решения проблемы исчезающего градиента.

Компоненты LSTM

• Входные ворота: Контролируют, какую новую информацию добавить в текущее состояние памяти нейрона в LSTM-сети.

• Забывающие ворота: Контролируют, какую информацию удалить из состояния памяти.

• Выходные ворота: Контролируют, какую информацию из состояния памяти использовать для текущего вывода.

GRU (Gated Recurrent Unit) — упрощенная версия LSTM с меньшим количеством ворот, которая зачастую показывает схожие результаты.

Компоненты GRU

• Ворот обновления: Контролирует, какую часть информации из памяти сохранить, а какую обновить с новой информацией.

• Ворот сброса: Контролирует, какую часть предыдущей информации забыть при вычислении нового состояния.

4.4 Трансформеры (BERT, GPT)

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

Ключевые компоненты

• Механизм внимания (Attention Mechanism): Позволяет модели определять, на какие части входных данных обратить больше внимания при обработке.

• Многоголовое внимание (Multi-Head Attention): Это расширение механизма внимания, которое позволяет модели фокусироваться на разных факторах последовательности одновременно.

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

Преимущества трансформеров

• Параллельная обработка: позволяет обучать модели быстрее при использовании GPU.

• Эффективная работа с длинными зависимостями: механизм внимания эффективно обрабатывает связи между отдаленными элементами.

BERT (Bidirectional Encoder Representations from Transformers)

• BERT — модель на основе трансформеров, обученная на большом объеме текстов.

• Двухнаправленная: учитывает контекст как слева, так и справа от целевого слова.

• Применение: задачи NLP, такие как классификация текста, ответы на вопросы и т.д.

GPT (Generative Pre-trained Transformer)

• GPT — серия моделей от OpenAI, использующих архитектуру трансформеров.

• Однонаправленная: предсказывает следующее слово на основе предыдущих.

• GPT o1, GPT 4, GPT 3: мощные модели, способные генерировать связный и осмысленный текст.

5. Реализация простых моделей с использованием TensorFlow/Keras

Установка библиотек:

pip install tensorflow

Импорт библиотек:

import numpy as np from tensorflow.keras.models import Sequential from tensorflow.keras.layers import SimpleRNN, Dense, Embedding from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.preprocessing.text import Tokenizer

Подготовка данных:

texts = [     "Хабр — популярная платформа для IT-специалистов",       "На Хабре можно найти статьи по программированию и технологиям",       "Пользователи Хабра делятся своим опытом и знаниями",       "Хабр помогает разработчикам узнавать о новых технологиях",       "Не все статьи на Хабре полезны",      "Иногда на Хабре сложно найти нужную информацию",       "Хабр может быть сложен для понимания новичками",       "Некоторые статьи на Хабре слишком технически сложны" ]  labels = [1, 1, 1, 1, 0, 0, 0, 0] # Метки (0 - негативный, 1 - позитивный)  labels = np.array(labels, dtype='float32') # Преобразуем метки в numpy.ndarray

Токенизация текста:

tokenizer = Tokenizer() tokenizer.fit_on_texts(texts) sequences = tokenizer.texts_to_sequences(texts)  word_index = tokenizer.word_index # Словарь print("Размер словаря:", len(word_index))

Вывод:

Размер словаря: 28

Паддинг последовательностей:

maxlen = 10 data = pad_sequences(sequences, maxlen=maxlen)

Создание модели:

model = Sequential() model.add(Embedding(input_dim=len(word_index) + 1, output_dim=32)) model.add(SimpleRNN(32)) model.add(Dense(1, activation='sigmoid'))

Компиляция модели:

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

Обучение модели:

model.fit(data, labels, epochs=10)

Вывод:

Давайте проверим, как работает обученная модель на новых данных.

Подготовим новые тексты для проверки:

test_texts = [     "Я нашёл полезную статью на Хабре о машинном обучении",            "На Хабре слишком много сложной информации для меня",               "Статьи на Хабре помогают мне развиваться как программисту",        "Иногда Хабр бывает непонятен новичкам в IT",                       "Обожаю читать обзоры новых технологий на Хабре",                   "На Хабре мало информации по интересующей меня теме",               "Хабр - отличный ресурс для IT-специалистов",                      "Сложно разобраться в статьях на Хабре без подготовки",         ]

Преобразуем новые тексты так же, как и обучающие данные:

test_sequences = tokenizer.texts_to_sequences(test_texts) # Преобразуем тексты в последовательности test_data = pad_sequences(test_sequences, maxlen=maxlen)  print("Преобразованные тестовые последовательности:") print(test_data) 

Вывод:

Сделаем предсказания на новых данных:

predictions = model.predict(test_data)

Вывод:

Выведем результаты предсказаний:

threshold = 0.5 # Порог классификации  for i, text in enumerate(test_texts):     prediction = predictions[i][0]     predicted_label = "Позитивный" if prediction >= threshold else "Негативный"     print(f"Текст: {text}")     print(f"Предсказание: {prediction:.4f}")     print(f"Класс: {predicted_label}")     print("-" * 50) 

Вывод:

6. Теперь рассмотрим реализацию LSTM c использованием PyTorch

Установка библиотек:

pip install torch

Импорт библиотек:

import numpy as np import torch import torch.nn as nn from torch.utils.data import DataLoader, Dataset from tensorflow.keras.preprocessing.text import Tokenizer

Подготовка данных:

texts = [     "Хабр — популярная платформа для IT-специалистов",     "На Хабре можно найти статьи по программированию и технологиям",     "Пользователи Хабра делятся своим опытом и знаниями",     "Хабр помогает разработчикам узнавать о новых технологиях",     "Не все статьи на Хабре полезны",     "Иногда на Хабре сложно найти нужную информацию",     "Хабр может быть сложен для понимания новичками",     "Некоторые статьи на Хабре слишком технически сложны" ]  labels = [1, 1, 1, 1, 0, 0, 0, 0] labels = np.array(labels, dtype='float32') # Преобразуем метки в массив NumPy maxlen = 10 # Параметр максимальной длины последовательности  tokenizer = Tokenizer() # Токенизация текста tokenizer.fit_on_texts(texts) word_index = tokenizer.word_index print("Размер словаря:", len(word_index))

Определение класса Dataset:

class TextDataset(Dataset):     def __init__(self, texts, labels, tokenizer, maxlen):         self.texts = texts         self.labels = labels         self.tokenizer = tokenizer         self.maxlen = maxlen      def __len__(self):         return len(self.texts)      def __getitem__(self, idx):            text = self.texts[idx] #Получаем текст         label = self.labels[idx] #Получаем метку          sequence = self.tokenizer.texts_to_sequences([text])[0] # Преобразуем текст в последовательность токенов          if len(sequence) < self.maxlen: # Применяем паддинг или обрезку последовательности             sequence = np.pad(sequence, (0, self.maxlen - len(sequence)), 'constant')         else:             sequence = sequence[:self.maxlen]          sequence = torch.tensor(sequence, dtype=torch.long)  # Преобразуем в тензоры PyTorch         label = torch.tensor(label, dtype=torch.float32)          return sequence, label 

Определение модели LSTM:

class LSTMModel(nn.Module):     def __init__(self, vocab_size, embedding_dim, hidden_dim):         super(LSTMModel, self).__init__()         self.embedding = nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim)         self.lstm = nn.LSTM(input_size=embedding_dim, hidden_size=hidden_dim, batch_first=True)         self.linear = nn.Linear(hidden_dim, 1)         self.sigmoid = nn.Sigmoid()      def forward(self, x): # x имеет размерность (batch_size, maxlen)         embeds = self.embedding(x)         # embeds имеет размерность (batch_size, maxlen, embedding_dim)         lstm_out, (hn, cn) = self.lstm(embeds)         out = self.linear(hn[-1]) #Используем скрытый слой         out = self.sigmoid(out)         return out 

Подготовка DataLoader и модели:

from torch.utils.data import DataLoader  dataset = TextDataset(texts, labels, tokenizer, maxlen) # Создаём датасет dataloader = DataLoader(dataset, batch_size=2, shuffle=True) # Создаём загрузчик данных  vocab_size = len(word_index) + 1   embedding_dim = 32 hidden_dim = 32  model = LSTMModel(vocab_size, embedding_dim, hidden_dim) # Инициализируем модель criterion = nn.BCELoss() # Инициализируем функцию потерь optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # Инициализируем оптимизатор

Обучение модели:

model.train()  num_epochs = 10  for epoch in range(num_epochs):     total_loss = 0     for sequences, labels_batch in dataloader:         optimizer.zero_grad()         outputs = model(sequences) # Прямой проход         outputs = outputs.squeeze()         loss = criterion(outputs, labels_batch) # Вычисляем потерю         loss.backward() # Обратный проходоптимизация         optimizer.step() # Оптимизация         total_loss += loss.item()     avg_loss = total_loss / len(dataloader)     print(f"Эпоха {epoch+1}, Потеря: {avg_loss:.4f}") 

Вывод:

Проверим модель на новых данных:

test_texts = [     "Хабр предоставляет отличные возможности для обучения",       "Некоторые статьи на Хабре трудно понять",                ]  test_sequences = [] # Преобразуем тексты в последовательности for text in test_texts:     sequence = tokenizer.texts_to_sequences([text])[0]     if len(sequence) < maxlen:         sequence = np.pad(sequence, (0, maxlen - len(sequence)), 'constant')     else:         sequence = sequence[:maxlen]     test_sequences.append(sequence)  test_sequences = torch.tensor(test_sequences, dtype=torch.long) # Преобразуем в тензор  model.eval() # Переводим модель в режим оценки  with torch.no_grad():     outputs = model(test_sequences)     predictions = outputs.squeeze().numpy()  threshold = 0.5  for i, text in enumerate(test_texts):     prediction = predictions[i]     predicted_label = "Позитивный" if prediction >= threshold else "Негативный"     print(f"Текст: {text}")     print(f"Предсказание: {prediction:.4f}")     print(f"Класс: {predicted_label}")     print("-" * 50) 

Вывод:

7. Вывод

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