Обработка естественного языка (NLP) — увлекательная область искусственного интеллекта, которая позволяет компьютерам понимать, интерпретировать человеческую речь и реагировать на нее. В этой статье мы рассмотрим передовые методы NLP, включая трансформирующие модели, механизмы внимания и контекстуальные встраивания. Мы также приведем примеры кода с использованием Python и популярных библиотек NLP.

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

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

Модель Transformer

Модель машинного обучения Transformer, произвела революцию в NLP, позволив выполнять параллельную обработку последовательностей данных. Существовавшие до этого традиционные RNN обрабатывали данные последовательно. Данная модель основана на механизме самовнимания (self‑attention) для выявления зависимостей между словами в предложении.

Архитектура модели Transformer состоит из кодировщика и декодировщика. Эти компоненты работают вместе, чтобы преобразовать входную последовательность данных в выходную.

Трансформеры предназначены для обработки последовательностей, таких как текст на естественном языке, и решения задач машинного перевода и автоматического реферирования. Как уже упоминалось, трансформеры в отличие от рекуррентных нейронных сетей (RNN), не требуют обработки последовательностей по порядку.

Кодировщик создает многомерное представление входной последовательности, которое декодировщик может использовать для генерации выходных данных. Декодировщик генерирует выходную последовательность на основе представлений кодировщика и ранее сгенерированных токенов.

Посмотрим программную реализацию на Python. В данном примере мы попробуем с помощью NLP перевести на французский английское предложение: The quick brown fox jumps over the lazy dog.

from transformers import T5Tokenizer, T5ForConditionalGeneration
tokenizer = T5Tokenizer.from_pretrained('t5-small')

model = T5ForConditionalGeneration.from_pretrained('t5-small')

text = "Translate English to French: The quick brown fox jumps over the lazy dog."
input_ids = tokenizer.encode(text, return_tensors='pt')
outputs = model.generate(input_ids)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Полученный в итоге перевод:

Le renard brun rapide saute sur le chien fâcheux.

Механизм внимания

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

Принцип работы построен на вычислении веса внимания для входного сигнала. Эти веса определяют, насколько сильно модель должна сосредоточиться на каждом элементе. Так, при переводе длинного предложения модель должна сосредоточиться на определённых исходных словах, чтобы сгенерировать правильное следующее слово в переводе.

Ниже приводится пример использования данной модели на Python:

import torch
import torch.nn.functional as F

def attention(query, key, value):
    scores = torch.matmul(query, key.transpose(-2, -1)) / torch.sqrt(torch.tensor(key.size(-1), dtype=torch.float32))
    attention_weights = F.softmax(scores, dim=-1)
    return torch.matmul(attention_weights, value)

query = torch.randn(1, 3, 64)
key = torch.randn(1, 3, 64)
value = torch.randn(1, 3, 64)

output = attention(query, key, value)

print(output)

Контекстное встраивание с помощью BERT

BERT (Bidirectional Encoder Representations from Transformers) генерирует векторные представления слов, которые учитывают их окружение в предложении. В отличие от статических аналогов (например, Word2Vec), BERT создаёт представления, динамически изменяющиеся в зависимости от контекста.

BERT использует двунаправленный подход: обрабатывает текст в обоих направлениях (слева направо и справа налево). Это позволяет модели анализировать контекст каждого слова, рассматривая все слова в предложении.

В этом примере для исходной фразы «The quick brown fox jumps over the lazy dog.» мы получим пакетный размер, длину последовательности и скрытый размер.

from transformers import BertTokenizer, BertModel
 
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')

text = "The quick brown fox jumps over the lazy dog."
inputs = tokenizer(text, return_tensors='pt')
outputs = model(**inputs)
print(outputs.last_hidden_state.shape)  # (batch_size, sequence_length, hidden_size)

Распознавание именованных объектов с помощью SpaCy

NER (Named Entity Recognition, распознавание именованных сущностей) — это задача в области NLP, которая заключается в автоматическом определении и классификации именованных сущностей в неструктурированном тексте по заранее определённым категориям.

Здесь в качестве примера мы рассмотрим использование библиотеки Spacy для работы с NER. На вход будет подано предложение «Apple is looking at buying U.K. startup for $1 billion» и необходимо будет классифицировать те сущности, из которых оно состоит.

import spacy

nlp = spacy.load('en_core_web_sm')
text = "Apple is looking at buying U.K. startup for $1 billion"
doc = nlp(text)

for ent in doc.ents:
    print(ent.text, ent.label_)

В итоге получаем следующее:

Apple ORG

U.K. GPE

$1 billion MONEY

Анализ настроений с помощью Hugging Face Transformers

Анализ настроений включает в себя определение настроений, выраженных в тексте. Для анализа настроений мы можем использовать предварительно обученные модели‑трансформеры.

Попробуем дать эмоциональную оценку фразе 'I love using NLP models!'.

from transformers import pipeline

classifier = pipeline('sentiment-analysis')
result = classifier('I love using NLP models!')[0]
print(f"Label: {result['label']}, with score: {round(result['score'], 4)}")

В результате получаем оценку:

Label: POSITIVE, with score: 0.9992

Обучающая визуализация с помощью Matplotlib

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

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

import torch
import torch.nn as nn
import torch.optim as optim

from torch.utils.data import DataLoader, TensorDataset
import matplotlib.pyplot as plt
from transformers import BertTokenizer, BertForSequenceClassification

# Sample data
texts = ["I love programming.", "The weather is great today.", "I am learning NLP.", "This is an advanced topic."]
labels = [1, 1, 1, 0]  # 1 for positive, 0 for neutral (for simplicity)

# Preprocess data

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
inputs = tokenizer(texts, return_tensors='pt', padding=True, truncation=True)
dataset = TensorDataset(inputs['input_ids'], inputs['attention_mask'], torch.tensor(labels))
data_loader = DataLoader(dataset, batch_size=2, shuffle=True)

# Model

model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=2e-5)

# Training loop

num_epochs = 4
train_losses = []
train_accuracies = []


for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0

    for batch in data_loader:
        input_ids, attention_mask, labels = batch
        optimizer.zero_grad()
        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        _, predicted = torch.max(outputs.logits, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    train_loss = running_loss / len(data_loader)
    train_accuracy = 100. * correct / total
    train_losses.append(train_loss)
    train_accuracies.append(train_accuracy)
  
    print(f'Epoch {epoch+1}/{num_epochs}, Loss: {train_loss:.4f}, Accuracy: {train_accuracy:.2f}%')

# Plotting the results

plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.plot(train_losses, label='Train Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.title('Train Loss vs Epochs')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(train_accuracies, label='Train Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.title('Train Accuracy vs Epochs')
plt.legend()

plt.tight_layout()
plt.show()

В результате получаем следующее:

Заключение

В этой статье мы рассмотрели несколько передовых методов NLP, включая модели‑трансформеры, механизмы внимания и контекстные встраивания. Мы также рассмотрели решение практических задач, таких как распознавание именованных объектов и анализ настроений. Используя такие библиотеки, как Hugging Face's transformers и spaCy, а также инструменты визуализации TensorBoard, мы можем создавать и анализировать сложные модели NLP.

Приглашаем вас на курс «NLP. Advanced», посвященный современным методам и инструментам промышленного применения обработки естественного языка.

Чтобы познакомиться с форматом обучения и преподавателями, приходите на демо-уроки:

• 30 октября в 20:00 — «Эволюция инференса LLM: от Hugging Face Transformers к vLLM». Записаться

• 13 ноября в 18:00 — «Современные RAG‑системы для борьбы с галлюцинациями LLM». Записаться

• 20 ноября в 18:00 — «Создаем LLM агентов на LangChain». Записаться

Рост в IT быстрее с Подпиской — дает доступ к 3-м курсам в месяц по цене одного. Подробнее