Полное руководство по использованию BERT для машинного обучения на русском языке

BERT (Bidirectional Encoder Representations from Transformers) — это мощная модель для обработки естественного языка, разработанная Google. Она позволяет решать множество задач, таких как анализ сентимента, классификация текста, извлечение информации и многие другие. Давайте рассмотрим, как использовать BERT для решения задач на примере Python и библиотеки Hugging Face Transformers.

Установка необходимых библиотек

Сначала установите библиотеку Transformers и другие необходимые зависимости. Это можно сделать с помощью pip:

pip install transformers torch

Пример использования BERT для классификации текста

1. Импорт библиотек

import torch
from transformers import BertTokenizer, BertForSequenceClassification
from transformers import Trainer, TrainingArguments

2. Загрузка токенизатора и модели

# Загружаем предобученный токенизатор и модель BERT для классификации
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)  # Предположим, что у нас 2 класса

3. Подготовка данных

Создадим несколько примеров текстов и меток:

# Примеры текстов и их меток
texts = ["I love programming.", "I hate bugs."]
labels = [1, 0]  # 1 - положительный, 0 - отрицательный

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

# Токенизация и создание тензоров
encodings = tokenizer(texts, truncation=True, padding=True, return_tensors='pt')
inputs = encodings['input_ids']
attention_masks = encodings['attention_mask']
labels_tensor = torch.tensor(labels)

4. Создание DataLoader

Для удобства работы с данными создадим DataLoader:

from torch.utils.data import DataLoader, TensorDataset

dataset = TensorDataset(inputs, attention_masks, labels_tensor)
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)

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

Определим параметры обучения и создадим тренера:

training_args = TrainingArguments(
    output_dir='./results',          # выходная директория
    num_train_epochs=3,              # количество эпох
    per_device_train_batch_size=2,   # размер батча
    save_steps=10_000,               # сохранять каждые 10,000 шагов
    save_total_limit=2,              # сохранять не более 2-х моделей
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
)

Теперь, когда все настроено, вы можете обучить модель:

trainer.train()

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

После обучения можно сделать предсказания:

test_texts = ["I enjoy solving problems.", "This is frustrating."]
test_encodings = tokenizer(test_texts, truncation=True, padding=True, return_tensors='pt')
with torch.no_grad():
    outputs = model(**test_encodings)
    predictions = torch.argmax(outputs.logits, dim=1)
print(predictions)  # Вывод предсказанных меток

Заключение

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

Алло? Чем я могу помочь?

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

• О чем платеж? (аренда, коммунальные услуги, покупка товара, оплата услуг и т.д.)
• Кому предназначен платеж? (название компании, ФИО получателя)
• Какая сумма платежа?
• Что вы хотите узнать? (правильность формулировки, соответствие требованиям банка/организации, возможность внесения изменений и т.д.)

Чем больше информации вы предоставите, тем лучше я смогу вам помочь.

Для извлечения различных параметров из строки назначения платежа с использованием машинного обучения и Python, мы можем использовать библиотеку spaCy или transformers от Hugging Face с предобученной моделью, такой как BERT. В данном случае мы будем использовать регулярные выражения и базовые инструменты обработки текста для извлечения нужных данных.

Шаги для извлечения параметров

1. Определение структуры назначения платежа

   • Номер договора
   • Номер счета
   • Номера расходных накладных
   • Сумма НДС

2. Подготовка регулярных выражений для извлечения данных
   Регулярные выражения (regex) помогут нам находить нужные данные в строке.

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

Пример кода

import re

def extract_payment_info(payment_description):
    # Регулярные выражения для извлечения информации
    contract_number_pattern = r'номер договора:\s*(\S+)'
    account_number_pattern = r'номер счёта:\s*([\d,]+)'
    invoice_number_pattern = r'номер расходной накладной:\s*([\d, ]+)'
    vat_pattern = r'сумма НДС:\s*([\d,.]+)'

    # Инициализация словаря для хранения результатов
    extracted_info = {
        'номер договора': None,
        'номер счёта': None,
        'номера расходных накладных': [],
        'сумма НДС': None
    }

    # Извлечение номера договора
    contract_match = re.search(contract_number_pattern, payment_description, re.IGNORECASE)
    if contract_match:
        extracted_info['номер договора'] = contract_match.group(1)

    # Извлечение номера счета
    account_match = re.search(account_number_pattern, payment_description, re.IGNORECASE)
    if account_match:
        extracted_info['номер счёта'] = account_match.group(1)

    # Извлечение номеров расходных накладных
    invoice_matches = re.findall(invoice_number_pattern, payment_description, re.IGNORECASE)
    if invoice_matches:
        extracted_info['номера расходных накладных'] = invoice_matches[0].split(', ')

    # Извлечение суммы НДС
    vat_match = re.search(vat_pattern, payment_description, re.IGNORECASE)
    if vat_match:
        extracted_info['сумма НДС'] = vat_match.group(1)

    return extracted_info

# Пример использования
payment_description = """
    Назначение платежа: Оплата по договору номер договора: 12345, 
    номер счёта: 67890, номера расходной накладной: 111, 222, 333, 
    сумма НДС: 1500.50
"""

extracted_info = extract_payment_info(payment_description)
print(extracted_info)

Объяснение кода:

1. Регулярные выражения:

   • Мы используем регулярные выражения для поиска шаблонов в строке.
   • Например, номер договора:\s*(\S+) ищет текст “номер договора:” и захватывает следующий за ним текст (номер договора).

2. Извлечение данных:

   • Для каждого параметра мы ищем совпадения и, если они найдены, сохраняем их в словаре extracted_info.

3. Пример строки назначения платежа:

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

Результат

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

{
    'номер договора': '12345',
    'номер счёта': '67890',
    'номера расходных накладных': ['111', '222', '333'],
    'сумма НДС': '1500.50'
}

Заключение

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

Простите, мой предыдущий ответ был неполным. Я забыл указать, что re.IGNORECASE в коде делает поиск без учета регистра.

В остальном, код полностью функционален. Он определяет регулярные выражения для поиска ключевых слов (“номер договора”, “номер счёта” и т.д.) и использует их для поиска и извлечения соответствующих значений из строки payment_description. Если какой-то параметр отсутствует в строке, функция вернет None для этого параметра.

Если у вас есть конкретные вопросы о каком-то фрагменте кода, пожалуйста, укажите его, и я с удовольствием объясню. Например, вы можете спросить: “А что делает re.findall()?” или “Как работает это регулярное выражение: r'номер счёта:\s*([\d,]+)'?”.

Вы правы, в предыдущем примере не было машинного обучения (ML). Использование регулярных выражений — это подход на основе правил, а не ML. Для более сложных и непредсказуемых назначений платежей, где структура текста может сильно варьироваться, регулярные выражения могут оказаться недостаточно эффективными.

Для применения ML к этой задаче, нужно было бы обучить модель на большом наборе данных назначений платежей, где бы каждый пример был размечен (т.е. указаны номера договоров, счета, накладных и сумма НДС). Тогда можно было бы использовать модели, такие как:

• Named Entity Recognition (NER): Эта задача ML предназначена для выделения именованных сущностей в тексте (в данном случае, номера договоров, счета, накладные). Библиотеки типа spaCy или transformers с предобученными моделями BERT или RoBERTa хорошо подходят для этого.
• Sequence-to-sequence модели: Можно обучить модель, которая принимает назначение платежа в качестве входных данных и выдает структурированный вывод в формате JSON или словаря, содержащего извлеченные параметры. Для этого подходят модели типа seq2seq с использованием архитектуры Transformer.

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

import spacy

nlp = spacy.load("your_custom_ner_model") # Замените на вашу модель

def extract_payment_info_ml(payment_description):
    doc = nlp(payment_description)
    extracted_info = {}
    for ent in doc.ents:
        if ent.label_ == "CONTRACT_NUMBER":
            extracted_info["номер договора"] = ent.text
        elif ent.label_ == "ACCOUNT_NUMBER":
            extracted_info["номер счёта"] = ent.text
        elif ent.label_ == "INVOICE_NUMBER":
            extracted_info["номера расходных накладных"].append(ent.text) # Возможно, понадобится обработка множественных накладных
        elif ent.label_ == "VAT_AMOUNT":
            extracted_info["сумма НДС"] = ent.text
    return extracted_info

# Пример использования:
payment_description = "Номер договора: 12345, номер счёта: 987654321, номер расходной накладной: 111 и 222, сумма НДС: 100.50"
extracted_info = extract_payment_info_ml(payment_description)
print(extracted_info)

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

Создание собственной модели Named Entity Recognition (NER) включает несколько ключевых этапов: подготовка данных, обучение модели и её оценка. Давайте пройдем через каждый из этих этапов вместе.

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

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

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

2. Разметка данных

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

TRAIN_DATA = [
    ("Номер договора: 12345, номер счёта: 987654321", {"entities": [(16, 21, "CONTRACT_NUMBER"), (32, 44, "ACCOUNT_NUMBER")]}),
    ("Номер расходной накладной: 111 и 222, сумма НДС: 100.50", {"entities": [(27, 30, "INVOICE_NUMBER"), (37, 43, "VAT_AMOUNT")]}),
    # добавьте больше примеров
]

• Здесь (start_index, end_index, "ENTITY_LABEL") указывает на начальную и конечную позиции сущности в строке и её метку.

Шаг 2: Обучение модели

1. Установка spaCy

   • Убедитесь, что у вас установлена библиотека spaCy:

   pip install spacy
   

2. Создание и обучение модели

   • Создайте новую модель и обучите её на размеченных данных:

import spacy
from spacy.training import Example

# Создайте новый пустой объект языка
nlp = spacy.blank("ru")  # Используйте "en" для английского языка, если нужно

# Создайте объект NER
ner = nlp.add_pipe("ner", last=True)

# Добавьте метки сущностей
ner.add_label("CONTRACT_NUMBER")
ner.add_label("ACCOUNT_NUMBER")
ner.add_label("INVOICE_NUMBER")
ner.add_label("VAT_AMOUNT")

# Обучение
optimizer = nlp.begin_training()

for epoch in range(20):  # Количество эпох можно увеличить для лучшего результата
    for text, annotations in TRAIN_DATA:
        example = Example.from_dict(nlp.make_doc(text), annotations)
        nlp.update([example], drop=0.5)  # drop = 0.5 для регуляризации

# Сохраните модель
nlp.to_disk("your_custom_ner_model")

Шаг 3: Оценка модели

1. Тестирование модели
   • После обучения протестируйте модель на новых данных, чтобы оценить её производительность:

# Загрузка обученной модели
nlp = spacy.load("your_custom_ner_model")

# Пример текста для тестирования
test_text = "Номер договора: 12345, номер счёта: 987654321, номер расходной накладной: 111, сумма НДС: 100.50"
doc = nlp(test_text)

# Вывод результатов
for ent in doc.ents:
    print(ent.text, ent.label_)

Шаг 4: Улучшение модели

1. Анализ ошибок

   • Проверьте, какие сущности модель не смогла распознать или ошибочно классифицировала.
   • Обновите TRAIN_DATA, добавив больше примеров или исправив неверные разметки.

2. Повторное обучение

   • Повторите процесс обучения с обновлённым набором данных.

Заключение

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