Конвертер аудиокниг на Qwen3 TTS: от PDF до голосового клона за один вечер

Почему Qwen3 TTS убивает ElevenLabs для аудиокниг (и почему об этом молчат)

Представьте: вы загружаете PDF с 500 страницами технической документации. Через 2 часа получаете аудиокнигу, где текст читает ваш собственный голос. Или голос любимого актера. Или синтезированный голос, который не звучит как робот из 90-х. И все это - без единого запроса в облако, без ограничений по длине, без ежемесячной подписки за $20+.

Это не фантастика. Это Qwen3 TTS - модель от Alibaba, которая на начало 2026 года обогнала по качеству большинство open-source решений, а по некоторым параметрам бьет даже коммерческие сервисы. Особенно в задачах длинного форматированного текста.

Но есть проблема: никто не говорит, как заставить эту штуку работать с реальными книгами, а не с парой абзацев. Вот что происходит, когда пытаешься скормить Qwen3 TTS целый EPUB:

• Модель глотает предложения целиком, игнорируя пунктуацию
• Длинные абзацы превращаются в монолог без пауз
• Сноски и примечания вставляются в середине предложений
• VRAM заканчивается на 20-й странице
• Голос "плывет" через несколько часов синтеза

Я потратил три недели на то, чтобы собрать конвейер, который работает. Не идеально, но работает. И сейчас покажу, как повторить.

1 Железо и софт: что реально нужно

Забудьте про запуск на ноутбуке с интегрированной графикой. Серьезно. Qwen3 TTS в режиме клонирования голоса требует минимум 8 ГБ VRAM для комфортной работы. На 6 ГБ можно попробовать, но будете постоянно бороться с out-of-memory.

Софтовая часть проще. Я тестировал два пути:

1. Чистый Python - для тех, кто любит контролировать каждый байт
2. Pinokio - однофайловое приложение, которое само скачивает модели и ставит зависимости

Pinokio - это магия. Качаете один файл, запускаете, выбираете "Qwen3 TTS" из каталога, и через 20 минут у вас работает веб-интерфейс. Но магия имеет цену: меньше контроля, черный ящик, сложнее дебажить.

Я пойду первым путем. Потому что когда что-то ломается (а оно ломается), нужно понимать где.

2 Установка: не верьте официальной документации

Официальный репозиторий Qwen3 TTS предлагает установку через pip. Что сломается:

# Так НЕ делать
pip install qwen3-tts  # Это установит базовую версию без voice cloning

Голосовое клонирование - отдельный пакет. И он требует специфичных версий зависимостей. Вот рабочий набор команд на январь 2026:

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

# Ставим torch с поддержкой CUDA 12.4 (актуально на 2026)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

# Основной пакет TTS
pip install qwen3-tts==2.1.0  # Последняя стабильная на момент написания

# Пакет для клонирования голоса
pip install qwen3-tts-voice-cloning==1.3.0

# Для обработки PDF
pip install pymupdf==1.24.0  # Быстрее pdfminer, меньше memory leaks
pip install ebooklib==0.18
pip install beautifulsoup4==4.12.3

# Для sentence boundary detection (самая важная часть!)
pip install spacy==3.7.4
python -m spacy download ru_core_news_lg  # Для русского
python -m spacy download en_core_web_lg    # Для английского

3 Архитектура: почему простой скрипт не работает

Можно написать 50 строк кода, которые возьмут текст и отправят в TTS. Результат будет ужасен. Потому что книги - это не просто текст. Это:

• Структура глав и подглав
• Сноски, которые нужно или читать, или пропускать
• Иллюстрации с подписями
• Таблицы, которые в аудиоформате бессмысленны
• Разрывы страниц, которые не должны быть паузами

Моя архитектура выглядит так:

# Не код для копирования, а схема
Конвейер:
1. PDF/EPUB → Извлечение чистого текста с метаданными
2. Текст → Очистка (удаление таблиц, обработка сносок)
3. Очищенный текст → Sentence segmentation (разбивка на предложения)
4. Предложения → Батчи по 5-7 предложений
5. Батчи → Qwen3 TTS с кэшированием
6. Аудиофрагменты → Сборка в главы с паузами
7. Главы → Один аудиофайл с метаданными ID3

Ключевой момент - пункт 3. Если отдавать Qwen3 TTS абзацы целиком, она будет читать их без естественных пауз. Spacy решает эту проблему.

4 Клонирование голоса: 30 секунд аудио меняют все

Голосовое клонирование в Qwen3 TTS работает иначе, чем в XTTS. Вместо обучения на вашем голосе (что требует часов и гигабайтов данных), используется few-shot подход. Вы даете образец голоса - модель адаптируется под него.

Что нужно для хорошего клона:

1. Чистая запись без фонового шума (используйте Whisper.cpp для очистки если нужно)
2. 30-60 секунд речи (не меньше!)
3. Разнообразные интонации: вопросы, утверждения, восклицания
4. Формат WAV, 22050 Hz, моно

Вот как выглядит инициализация с клонированием:

from qwen3_tts import Qwen3TTS
from qwen3_tts_voice_cloning import VoiceCloningManager
import torch

# Проверяем доступность GPU
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using device: {device}")

# Загружаем базовую модель TTS
tts = Qwen3TTS.from_pretrained(
    "Qwen/Qwen3-TTS-1.8B",
    torch_dtype=torch.float16,
    device_map="auto"
)

# Инициализируем менеджер клонирования
voice_manager = VoiceCloningManager(tts)

# Загружаем образец голоса
with open("my_voice_sample.wav", "rb") as f:
    audio_data = f.read()

# Создаем клон
cloned_voice = voice_manager.create_voice_from_audio(
    audio_data,
    voice_name="my_cloned_voice",
    language="ru"  # или "en", "de", "fr" и т.д.
)

# Теперь используем этот голос для синтеза
text = "Привет, это мой клонированный голос для аудиокниг."
audio = tts.generate(
    text,
    voice=cloned_voice,
    speed=1.0,
    temperature=0.7  # Чем ниже, тем стабильнее голос
)

5 Sentence Boundary Detection: магия, без которой все развалится

Вот где большинство самодельных конвертеров падают. Брать текст и делить его по точкам? Смешно. В книгах есть:

• Инициалы с точками (А.С. Пушкин)
• Сокращения (т.е., и т.д., др.)
• Десятичные числа (3.14)
• Многоточия...
• Точки в цитатах внутри предложений

Spacy решает 90% этих проблем. Но нужно правильно настроить:

import spacy

# Загружаем модель (уже скачали ранее)
nlp = spacy.load("ru_core_news_lg")

# Пример текста из книги
text = "Д-р Ватсон, как вы знаете, жил в Лондоне по адресу Бейкер-стрит, 221б. Это было в 1887 г. В то время..."

doc = nlp(text)

# Извлекаем предложения
sentences = [sent.text for sent in doc.sents]

print("Разбито на предложения:")
for i, sent in enumerate(sentences[:3], 1):
    print(f"{i}. {sent}")

Результат будет правильным: "Д-р Ватсон, как вы знаете, жил в Лондоне по адресу Бейкер-стрит, 221б." - одно предложение. "Это было в 1887 г." - второе. Spacy понимает, что "д-р" и "г." - это не концы предложений.

6 Интеллектуальное кэширование: не генерировать дважды

Представьте: вы конвертируете книгу, процесс прервался на 90%. Без кэша придется начинать сначала. С кэшем - продолжить с места падения.

Моя система кэширования учитывает:

1. Текст предложения (хеш SHA256)
2. Параметры голоса (название клона)
3. Настройки TTS (скорость, температура)
4. Язык

import hashlib
import json
import os
from pathlib import Path

class TTSCache:
    def __init__(self, cache_dir="tts_cache"):
        self.cache_dir = Path(cache_dir)
        self.cache_dir.mkdir(exist_ok=True)
        
        # Файл манифеста для быстрого поиска
        self.manifest_path = self.cache_dir / "manifest.json"
        if self.manifest_path.exists():
            with open(self.manifest_path, "r", encoding="utf-8") as f:
                self.manifest = json.load(f)
        else:
            self.manifest = {}
    
    def get_cache_key(self, text, voice_name, language, speed, temperature):
        """Создаем уникальный ключ для комбинации параметров"""
        params_str = f"{text}|{voice_name}|{language}|{speed}|{temperature}"
        return hashlib.sha256(params_str.encode("utf-8")).hexdigest()
    
    def get(self, text, voice_name, language="ru", speed=1.0, temperature=0.7):
        """Пытаемся найти аудио в кэше"""
        key = self.get_cache_key(text, voice_name, language, speed, temperature)
        
        if key in self.manifest:
            audio_path = self.cache_dir / self.manifest[key]["filename"]
            if audio_path.exists():
                print(f"Cache hit for: {text[:50]}...")
                with open(audio_path, "rb") as f:
                    return f.read()
        
        return None
    
    def put(self, text, voice_name, audio_data, language="ru", speed=1.0, temperature=0.7):
        """Сохраняем аудио в кэш"""
        key = self.get_cache_key(text, voice_name, language, speed, temperature)
        
        filename = f"{key}.wav"
        audio_path = self.cache_dir / filename
        
        with open(audio_path, "wb") as f:
            f.write(audio_data)
        
        # Обновляем манифест
        self.manifest[key] = {
            "filename": filename,
            "text_preview": text[:100],
            "voice": voice_name,
            "timestamp": time.time()
        }
        
        # Периодически сохраняем манифест
        with open(self.manifest_path, "w", encoding="utf-8") as f:
            json.dump(self.manifest, f, ensure_ascii=False, indent=2)

Эта система экономит до 40% времени при повторной конвертации той же книги с теми же настройками. Или при возобновлении после сбоя.

7 Обработка PDF и EPUB: где собака зарыта

PDF - это ад. Каждый PDF сгенерирован по-своему. Некоторые выглядят как текст, а внутри - картинки с текстом. Другие имеют кривую кодировку. Третьи используют кастомные шрифты.

PyMuPDF (fitz) - меньшее из зол. Вот базовый обработчик:

import fitz  # PyMuPDF
import re

def extract_text_from_pdf(pdf_path, max_pages=None):
    """Извлекаем текст из PDF с базовой очисткой"""
    doc = fitz.open(pdf_path)
    
    all_text = []
    metadata = {
        "title": doc.metadata.get("title", ""),
        "author": doc.metadata.get("author", ""),
        "total_pages": len(doc)
    }
    
    for page_num, page in enumerate(doc):
        if max_pages and page_num >= max_pages:
            break
            
        text = page.get_text("text")
        
        # Базовая очистка
        text = re.sub(r'\s+', ' ', text)  # Множественные пробелы
        text = re.sub(r'\n{3,}', '\n\n', text)  # Множественные переносы
        
        # Удаляем номера страниц внизу (если они есть)
        lines = text.split('\n')
        if len(lines) > 1 and lines[-1].strip().isdigit():
            lines = lines[:-1]
            text = '\n'.join(lines)
        
        all_text.append({
            "page": page_num + 1,
            "text": text.strip()
        })
    
    doc.close()
    return {
        "metadata": metadata,
        "pages": all_text
    }

EPUB проще. Ebooklib дает структурированный доступ к главам:

from ebooklib import epub
from bs4 import BeautifulSoup

def extract_chapters_from_epub(epub_path):
    """Извлекаем главы из EPUB"""
    book = epub.read_epub(epub_path)
    
    chapters = []
    
    for item in book.get_items():
        if item.get_type() == ebooklib.ITEM_DOCUMENT:
            # Парсим HTML главы
            soup = BeautifulSoup(item.get_content(), 'html.parser')
            
            # Удаляем скрипты, стили
            for script in soup(["script", "style"]):
                script.decompose()
            
            # Получаем чистый текст
            text = soup.get_text()
            text = re.sub(r'\s+', ' ', text)
            
            if text.strip():
                chapters.append({
                    "title": item.get_name(),
                    "content": text.strip()
                })
    
    return chapters

8 Сборка всего вместе: главный скрипт

Вот скелет основного скрипта. Полная версия занимает 400 строк, но суть здесь:

import argparse
from pathlib import Path
from tts_engine import Qwen3TTSEngine
from text_processor import TextProcessor
from cache_manager import TTSCache
from audio_assembler import AudioAssembler

def main():
    parser = argparse.ArgumentParser(description="Конвертер книг в аудио с Qwen3 TTS")
    parser.add_argument("--input", required=True, help="PDF или EPUB файл")
    parser.add_argument("--voice-sample", help="WAV файл для клонирования голоса")
    parser.add_argument("--output", default="output", help="Папка для результатов")
    parser.add_argument("--language", default="ru", help="Язык (ru, en, etc)")
    parser.add_argument("--batch-size", type=int, default=5, help="Количество предложений в батче")
    
    args = parser.parse_args()
    
    # Инициализируем компоненты
    tts_engine = Qwen3TTSEngine(device="cuda")
    text_processor = TextProcessor(language=args.language)
    cache = TTSCache(cache_dir="tts_cache")
    assembler = AudioAssembler()
    
    # Клонируем голос если есть образец
    if args.voice_sample:
        print("Клонируем голос...")
        with open(args.voice_sample, "rb") as f:
            voice_data = f.read()
        voice = tts_engine.clone_voice(voice_data, "custom_voice")
    else:
        voice = "default"
    
    # Обрабатываем входной файл
    input_path = Path(args.input)
    if input_path.suffix.lower() == ".pdf":
        book_data = text_processor.process_pdf(input_path)
    elif input_path.suffix.lower() == ".epub":
        book_data = text_processor.process_epub(input_path)
    else:
        raise ValueError("Поддерживаются только PDF и EPUB")
    
    # Конвертируем каждую главу
    all_audio_chunks = []
    
    for chapter_idx, chapter in enumerate(book_data["chapters"]):
        print(f"Обрабатываем главу {chapter_idx + 1}/{len(book_data['chapters'])}")
        
        # Разбиваем на предложения
        sentences = text_processor.split_into_sentences(chapter["content"])
        
        # Группируем в батчи
        sentence_batches = text_processor.create_batches(sentences, args.batch_size)
        
        chapter_audio = []
        
        for batch_idx, batch in enumerate(sentence_batches):
            batch_text = " ".join(batch)
            
            # Пробуем взять из кэша
            cached_audio = cache.get(batch_text, voice, args.language)
            
            if cached_audio:
                audio = cached_audio
            else:
                # Генерируем через TTS
                audio = tts_engine.generate(
                    batch_text,
                    voice=voice,
                    language=args.language,
                    temperature=0.7
                )
                # Сохраняем в кэш
                cache.put(batch_text, voice, audio, args.language)
            
            chapter_audio.append(audio)
            
            print(f"  Батч {batch_idx + 1}/{len(sentence_batches)} готов")
        
        # Собираем главу
        chapter_file = assembler.assemble_chapter(chapter_audio, chapter["title"])
        all_audio_chunks.append(chapter_file)
    
    # Собираем всю книгу
    final_audio = assembler.assemble_book(
        all_audio_chunks,
        title=book_data["metadata"].get("title", "Аудиокнига"),
        author=book_data["metadata"].get("author", "")
    )
    
    print(f"Готово! Аудиокнига сохранена в {final_audio}")

if __name__ == "__main__":
    main()

Ошибки, которые сломают ваш день (и как их избежать)

За месяц тестирования я наступил на все грабли. Вот главные:

Производительность: что ждать в реальности

На RTX 4070 12GB:

• Страница текста (300 слов): 15-25 секунд генерации
• 300-страничная книга: 4-6 часов
• Использование VRAM: 8-10 ГБ пиковое
• Размер аудиофайла: ~10 МБ на час аудио (MP3 64kbps)

Это медленнее, чем XTTS, но качество лучше. Особенно для русского языка - Qwen3 TTS тренировалась на огромном русскоязычном датасете, произношение сложных слов значительно натуральнее.

Что дальше? Будущее локальных TTS

На январь 2026 Qwen3 TTS - одна из лучших open-source моделей для аудиокниг. Но технологии не стоят на месте. Что я жду в ближайшие год-два:

1. Мультиголосое чтение - разные персонажи разными голосами в одной книге. Технически возможно уже сейчас, но требует ручной разметки текста.
2. Эмоциональное окрашивание - модель будет понимать контекст и добавлять эмоции в чтение. Сейчас это делается через промпты ("читай грустно"), но плохо работает на длинных текстах.
3. Полная оффлайн цепочка - от скана книги до аудио без единого запроса в интернет. OCR + TTS в одном конвейере.

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

Последний совет: начните с короткой книги. 50 страниц максимум. Отладьте конвейер, поймите, как ведет себя ваше железо. Потом беритесь за "Войну и мир". И обязательно делайте перерывы в генерации - и для GPU, и для ваших ушей. Слушать 8 часов синтезированной речи подряд - сомнительное удовольствие.