Тренируем LLM на своих EPUB: какой компактную модель выбрать и как это сделать

Проблема: Почему ChatGPT не знает мои книги?

Вы читаете много книг в формате EPUB — техническую литературу, художественные произведения, научные статьи. У вас формируется уникальная библиотека знаний. Но когда вы задаете вопрос ChatGPT или Claude о содержании ваших книг, модель отвечает общими фразами или вовсе молчит. Почему?

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

Решение: Компактные модели для домашнего обучения

Вам не нужна GPT-4 с 1.7 триллионами параметров. Для работы с персональными данными достаточно «легких» моделей на 3-13 миллиардов параметров, которые можно обучать на потребительском GPU или даже CPU с достаточным объемом RAM.

Критерии выбора модели

• Размер: 3B-13B параметров (оптимальный баланс качества и требований)
• Архитектура: Поддержка эффективного обучения (LoRA, QLoRA)
• Лицензия: Разрешает коммерческое использование и модификацию
• Качество: Хорошие результаты на стандартных бенчмарках

Пошаговый план: От EPUB до обученной модели

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

1 Подготовка среды и установка зависимостей

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

# Создаем виртуальное окружение
python -m venv llm-epub-env
source llm-epub-env/bin/activate  # На Windows: llm-epub-env\Scripts\activate

# Устанавливаем базовые зависимости
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118  # Для CUDA 11.8
pip install transformers datasets accelerate peft bitsandbytes
pip install ebooklib beautifulsoup4  # Для работы с EPUB
pip install sentencepiece protobuf  # Для токенизаторов

2 Извлечение и очистка текста из EPUB

EPUB — это по сути ZIP-архив с HTML-файлами. Нам нужно извлечь чистый текст, удалив разметку, оглавления, колонтитулы.

import ebooklib
from ebooklib import epub
from bs4 import BeautifulSoup
import re

def extract_text_from_epub(epub_path):
    book = epub.read_epub(epub_path)
    texts = []
    
    for item in book.get_items():
        if item.get_type() == ebooklib.ITEM_DOCUMENT:
            soup = BeautifulSoup(item.get_content(), 'html.parser')
            # Удаляем скрипты, стили, навигацию
            for element in soup(['script', 'style', 'nav', 'header', 'footer']):
                element.decompose()
            
            text = soup.get_text()
            # Очищаем лишние пробелы и переносы
            text = re.sub(r'\s+', ' ', text).strip()
            if text and len(text) > 100:  # Игнорируем очень короткие фрагменты
                texts.append(text)
    
    return ' '.join(texts)

# Пример использования
book_text = extract_text_from_epub('my_book.epub')
print(f"Извлечено символов: {len(book_text)}")

3 Подготовка датасета для обучения

Текст нужно разбить на фрагменты подходящего размера и преобразовать в формат, понятный модели (парные примеры «вопрос-ответ» или продолжение текста).

from datasets import Dataset
import json

def create_chunks(text, chunk_size=512):
    """Разбиваем текст на перекрывающиеся чанки"""
    words = text.split()
    chunks = []
    
    for i in range(0, len(words), chunk_size // 2):  # 50% перекрытие
        chunk = ' '.join(words[i:i + chunk_size])
        if len(chunk.split()) > 50:  # Минимальный размер чанка
            chunks.append({"text": chunk})
    
    return chunks

# Создаем датасет
chunks = create_chunks(book_text, chunk_size=512)
dataset = Dataset.from_list(chunks)

# Сохраняем для последующего использования
dataset.save_to_disk("./epub_dataset")
print(f"Создано {len(chunks)} чанков для обучения")

4 Загрузка модели и применение QLoRA

QLoRA (Quantized Low-Rank Adaptation) позволяет обучать большие модели на малом VRAM, квантуя веса до 4-bit и обучая только небольшие адаптеры.

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
import torch

# Конфигурация 4-bit квантования
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True
)

# Загружаем модель с квантованием
model_name = "meta-llama/Llama-3.2-3B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)

tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token  # Устанавливаем pad токен

# Подготавливаем модель для k-bit обучения
model = prepare_model_for_kbit_training(model)

# Конфигурация LoRA
lora_config = LoraConfig(
    r=16,  # Rank
    lora_alpha=32,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

# Применяем LoRA к модели
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()  # Покажет ~1% обучаемых параметров

5 Обучение модели на ваших данных

Настраиваем параметры обучения и запускаем процесс. Для небольшой библиотеки (5-10 книг) обычно достаточно 3-5 эпох.

from transformers import TrainingArguments, Trainer

# Токенизация датасета
def tokenize_function(examples):
    return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=512)

tokenized_dataset = dataset.map(tokenize_function, batched=True)

# Параметры обучения
training_args = TrainingArguments(
    output_dir="./llama-epub-trained",
    num_train_epochs=3,
    per_device_train_batch_size=2,  # Уменьшайте если не хватает памяти
    gradient_accumulation_steps=4,
    warmup_steps=100,
    logging_steps=10,
    save_steps=200,
    evaluation_strategy="no",
    learning_rate=2e-4,
    fp16=True,  # Используем половинную точность
    optim="paged_adamw_8bit",
    save_total_limit=2,
    report_to="none"  # Отключаем отчеты
)

# Создаем тренер
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
    tokenizer=tokenizer,
)

# Запускаем обучение
trainer.train()

# Сохраняем обученную модель
model.save_pretrained("./my_epub_llm")
tokenizer.save_pretrained("./my_epub_llm")

6 Тестирование и использование модели

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

from peft import PeftModel

# Загружаем базовую модель и адаптеры
base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.2-3B-Instruct",
    device_map="auto",
    torch_dtype=torch.float16
)

trained_model = PeftModel.from_pretrained(base_model, "./my_epub_llm")

trained_model.eval()

# Тестовый запрос
prompt = "В книге, которую я тебе дал, рассказывается о..."
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

with torch.no_grad():
    outputs = trained_model.generate(
        **inputs,
        max_new_tokens=200,
        temperature=0.7,
        do_sample=True
    )

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

Нюансы и возможные ошибки

Оптимизация для разных конфигураций железа

• GPU с 8GB VRAM: Используйте QLoRA с 4-bit квантованием, batch size = 1, gradient accumulation = 8
• Только CPU (32GB+ RAM): Рассмотрите Phi-3 Mini, используйте 8-bit квантование, уменьшите длину контекста до 512
• GPU с 24GB VRAM: Можно обучать 7B модели без квантования или использовать полный fine-tuning

Типичные ошибки и их решения

Альтернативы и когда их использовать

Fine-tuning — не единственный способ работы с персональными данными. Выбор зависит от ваших целей:

FAQ: Частые вопросы

Сколько книг нужно для качественного обучения?

Минимум — 3-5 полноценных книг (общим объемом 500+ страниц). Оптимально — 10-20 книг одной тематики. Качество важнее количества: лучше 5 хорошо очищенных книг, чем 20 с шумом.

Можно ли обучать на книгах на русском языке?

Да, но выбирайте мультиязычные модели (Qwen2.5, некоторые версии Llama) или русскоязычные (Saiga, Rugpt). Англоязычные модели будут работать хуже с кириллицей.

Сколько времени займет обучение?

На RTX 4070 (12GB) обучение Llama 3.2 3B на 10 книгах (~500k токенов):
- Подготовка данных: 10-30 минут
- Обучение (3 эпохи): 2-4 часа
- Тестирование и настройка: 1-2 часа

Как интегрировать обученную модель в приложение?

Используйте FastAPI для создания REST API или напрямую интегрируйте в Python-приложение. Для веб-интерфейса подойдет Gradio или Streamlit. Подробнее о продакшн-интеграции читайте в нашем гайде по интеграции ML моделей.

Заключение

Создание персонального ИИ, который действительно знает ваши книги, перестало быть фантастикой. Благодаря компактным моделям и эффективным методам обучения вроде QLoRA, это можно сделать на домашнем компьютере.

Начните с малого: возьмите 2-3 любимые книги, выберите Llama 3.2 3B, и следуйте пошаговому плану. Первые результаты вы увидите уже через несколько часов работы.

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