Как создать автономный Infinite Podcast на локальных моделях: полный гайд с Python и RTX 5060 Ti

Почему автономный подкаст — это не безумие, а необходимость

Представьте: вы запускаете скрипт, уходите пить кофе, а через час получаете готовый часовой подкаст на любую тему. Без платных API, без ограничений по токенам, без зависимости от интернета. Звучит как фантастика? Это реальность, которую можно собрать на одной видеокарте.

Я видел десятки проектов, где люди пытались сделать что-то подобное на облачных сервисах. Месячный бюджет в $500 улетал за неделю. Потом приходили лимиты, потом баны за "чрезмерное использование". Это тупиковый путь.

Что такое Infinite Podcast и почему он "бесконечный"

Infinite Podcast — это система, которая генерирует контент по заданной теме, разбивает его на логические сегменты (вступление, основная часть, вопросы, заключение), синтезирует речь и сохраняет в аудиофайлы. "Бесконечный" потому что он может работать сутками, создавая эпизоды один за другим.

Железо: почему RTX 5060 Ti, а не что-то мощнее

Все гонятся за RTX 5090, забывая простую истину: эффективность важнее мощности. RTX 5060 Ti с 16 ГБ VRAM — идеальный баланс для локальных LLM. Почему?

• Достаточно памяти для 7B-модели с контекстом 8K
• Энергоэффективность — можно оставлять работать на ночь
• Доступная цена (относительно, конечно)
• Поддержка всех современных библиотек через CUDA

Если у вас другая карта — не проблема. В моем гайде по запуску локальных LLM на доступном железе я подробно разбирал альтернативы.

Архитектура системы: что куда и зачем

Система состоит из трех основных компонентов, которые работают как конвейер:

Важный момент: модели не работают одновременно. Сначала LLM генерирует текст, освобождает память, потом загружается TTS. Так мы умещаемся в 16 ГБ.

1 Подготовка окружения: установка без боли

Первая ошибка новичков — пытаться установить всё через pip без виртуального окружения. Через неделю такая система превращается в свалку конфликтующих зависимостей.

# Создаем чистое окружение
python -m venv podcast_env
source podcast_env/bin/activate  # На Windows: podcast_env\Scripts\activate

# Устанавливаем базовые зависимости
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install transformers accelerate sentencepiece
pip install TTS  # Для XTTS
pip install soundfile  # Для работы с аудио

2 Загрузка моделей: как не скачать 100 ГБ мусора

Модели нужно скачивать с умом. Qwen2.5-7B-Instruct весит около 15 ГБ в формате GGUF. Но нам нужна не любая версия, а конкретно та, что оптимизирована для нашего железа.

# config.py - конфигурация моделей
MODEL_CONFIG = {
    "llm": {
        "name": "Qwen/Qwen2.5-7B-Instruct-GGUF",
        "filename": "qwen2.5-7b-instruct-q4_K_M.gguf",
        "context_size": 8192,
        "gpu_layers": 35,  # Для RTX 5060 Ti
        "temperature": 0.7,
        "top_p": 0.9
    },
    "tts": {
        "name": "tts_models/multilingual/multi-dataset/xtts_v2",
        "speaker_wav": "samples/speaker.wav",  # Референсный голос
        "language": "ru"  # Русский язык
    }
}

Для загрузки моделей используйте huggingface-cli, но с флагом --local-dir-use-symlinks False. Иначе вы получите симлинки, которые сломаются при перемещении.

# Скачиваем LLM
huggingface-cli download TheBloke/Qwen2.5-7B-Instruct-GGUF \
    qwen2.5-7b-instruct-q4_K_M.gguf \
    --local-dir models/llm \
    --local-dir-use-symlinks False

# Скачиваем TTS (первый запуск скачает модель)
python -c "from TTS.api import TTS; tts = TTS('tts_models/multilingual/multi-dataset/xtts_v2')"

3 Ядро системы: оркестратор на Python

Вот где большинство проектов умирают. Люди пишут монолитный скрипт на 500 строк, который через день перестает работать. Мы сделаем модульную систему.

# orchestrator.py - основная логика
import torch
from llm_manager import LLMManager
from tts_manager import TTSManager
import json
import time

class PodcastOrchestrator:
    def __init__(self, config_path="config.json"):
        with open(config_path, 'r') as f:
            self.config = json.load(f)
        
        self.llm = None
        self.tts = None
        self.current_topic = ""
        self.episode_counter = 1
        
    def initialize_models(self):
        """Инициализируем модели по очереди"""
        print("Инициализация LLM...")
        self.llm = LLMManager(self.config['llm'])
        
        # Освобождаем память перед загрузкой TTS
        torch.cuda.empty_cache()
        
        print("Инициализация TTS...")
        self.tts = TTSManager(self.config['tts'])
        
    def generate_episode(self, topic, duration_minutes=30):
        """Генерируем один эпизод подкаста"""
        print(f"Генерация эпизода на тему: {topic}")
        
        # Генерируем структуру подкаста
        structure = self.llm.generate_structure(topic, duration_minutes)
        
        # Для каждого сегмента генерируем текст и синтезируем речь
        audio_segments = []
        for segment in structure['segments']:
            text = self.llm.generate_segment(segment['type'], segment['prompt'])
            audio_path = self.tts.synthesize(text, f"temp_segment_{len(audio_segments)}.wav")
            audio_segments.append({
                'text': text,
                'audio': audio_path,
                'duration': segment.get('target_duration', 180)
            })
            
            # Проверяем, не превысили ли общую длительность
            total_duration = sum(s['duration'] for s in audio_segments)
            if total_duration >= duration_minutes * 60:
                break
        
        # Объединяем сегменты в один файл
        final_path = f"episodes/episode_{self.episode_counter:03d}.wav"
        self._combine_audio(audio_segments, final_path)
        
        self.episode_counter += 1
        return final_path
        
    def run_infinite(self, topics_file="topics.txt"):
        """Бесконечный цикл генерации"""
        with open(topics_file, 'r') as f:
            topics = [line.strip() for line in f if line.strip()]
        
        topic_index = 0
        while True:
            try:
                current_topic = topics[topic_index % len(topics)]
                episode_path = self.generate_episode(current_topic)
                print(f"Эпизод сохранен: {episode_path}")
                
                # Пауза между эпизодами
                time.sleep(self.config.get('pause_between_episodes', 300))
                
                topic_index += 1
                
            except KeyboardInterrupt:
                print("\nОстановка по запросу пользователя")
                break
            except Exception as e:
                print(f"Ошибка: {e}")
                # Пробуем переинициализировать модели
                self.initialize_models()

4 LLM менеджер: умная генерация текста

Самая сложная часть — заставить LLM генерировать текст, который звучит естественно в аудиоформате. Письменная речь и устная — разные вещи.

# llm_manager.py
from llama_cpp import Llama
import json

class LLMManager:
    def __init__(self, config):
        self.config = config
        self.model = Llama(
            model_path=f"models/llm/{config['filename']}",
            n_ctx=config['context_size'],
            n_gpu_layers=config['gpu_layers'],
            verbose=False
        )
        
    def generate_structure(self, topic, duration_minutes):
        """Генерируем структуру подкаста"""
        prompt = f"""Ты — ведущий подкаста. Создай структуру для эпизода на тему "{topic}". 
Длительность: {duration_minutes} минут.

Верни ответ в формате JSON:
{{
  "segments": [
    {{"type": "intro", "prompt": "Текст для вступления", "target_duration": 60}},
    {{"type": "main_part_1", "prompt": "Первый ключевой тезис", "target_duration": 300}},
    {{"type": "transition", "prompt": "Переход ко второй части", "target_duration": 60}},
    {{"type": "main_part_2", "prompt": "Второй ключевой тезис", "target_duration": 300}},
    {{"type": "qanda", "prompt": "Вопросы и ответы по теме", "target_duration": 180}},
    {{"type": "outro", "prompt": "Заключение и анонс следующего эпизода", "target_duration": 120}}
  ]
}}

Сумма target_duration должна быть примерно {duration_minutes * 60} секунд."""
        
        response = self.model(
            prompt,
            max_tokens=1024,
            temperature=0.3,  # Низкая температура для структурированного вывода
            stop=["\n"]
        )
        
        # Извлекаем JSON из ответа
        text = response['choices'][0]['text']
        json_start = text.find('{')
        json_end = text.rfind('}') + 1
        
        if json_start != -1 and json_end != -1:
            json_str = text[json_start:json_end]
            return json.loads(json_str)
        else:
            # Fallback структура
            return self._default_structure(topic, duration_minutes)
    
    def generate_segment(self, segment_type, prompt):
        """Генерируем текст для конкретного сегмента"""
        system_prompt = """Ты — ведущий подкаста. Твой текст будет озвучен. 
Используй:
- Короткие предложения
- Естественные паузы (обозначай их как [...])
- Разговорный стиль
- Избегай сложных терминов без объяснения
"""
        
        user_prompt = f"Напиши текст для сегмента типа '{segment_type}'. Ключевые темы: {prompt}"
        
        full_prompt = f"<|im_start|>system\n{system_prompt}<|im_end|>\n<|im_start|>user\n{user_prompt}<|im_end|>\n<|im_start|>assistant\n"
        
        response = self.model(
            full_prompt,
            max_tokens=1024,
            temperature=self.config['temperature'],
            top_p=self.config['top_p'],
            stop=["<|im_end|>"]
        )
        
        return response['choices'][0]['text']

Типичные ошибки и как их избежать

Ошибка 1: Модель генерирует "книжный" текст

LLM обучены на письменных текстах. Они выдают сложные конструкции, которые ужасно звучат в аудио. Решение — промпт-инжиниринг. Явно указывайте в системном промпте: "Текст будет озвучен. Используй разговорный стиль."

Ошибка 2: TTS съедает всю память

XTTS-v2 может занимать до 4 ГБ VRAM, если не настроить правильно. Используйте float16 вместо float32, отключайте ненужные компоненты:

# tts_manager.py - оптимизированная версия
from TTS.api import TTS
import torch

class TTSManager:
    def __init__(self, config):
        self.config = config
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        
        # Ключевой момент: загружаем с оптимизациями
        self.model = TTS(config['name']).to(self.device)
        
        if self.device == "cuda":
            # Используем float16 для экономии памяти
            self.model.model.half()
            torch.cuda.empty_cache()
    
    def synthesize(self, text, output_path):
        """Синтезируем речь с оптимизациями"""
        # Ограничиваем длину текста для стабильности
        if len(text) > 1000:
            text = text[:1000] + "..."
        
        self.model.tts_to_file(
            text=text,
            speaker_wav=self.config['speaker_wav'],
            language=self.config['language'],
            file_path=output_path
        )
        return output_path

Ошибка 3: Система "забывает" контекст между эпизодами

Это архитектурная проблема. Нужно сохранять ключевые моменты из предыдущих эпизодов и передавать их в следующий. Самый простой способ — вести лог в JSON:

# В orchestrator.py добавляем
class PodcastOrchestrator:
    # ... остальной код ...
    
    def __init__(self, config_path="config.json"):
        # ... инициализация ...
        self.memory_file = "podcast_memory.json"
        self.load_memory()
    
    def load_memory(self):
        if os.path.exists(self.memory_file):
            with open(self.memory_file, 'r') as f:
                self.memory = json.load(f)
        else:
            self.memory = {"previous_topics": [], "key_points": {}}
    
    def save_memory(self):
        with open(self.memory_file, 'w') as f:
            json.dump(self.memory, f, indent=2)
    
    def generate_episode(self, topic, duration_minutes=30):
        # Добавляем контекст из памяти в промпт
        context = ""
        if topic in self.memory["key_points"]:
            context = f"Ранее мы обсуждали: {', '.join(self.memory['key_points'][topic][:3])}"
        
        # ... остальная генерация ...
        
        # Сохраняем ключевые точки
        self.memory["previous_topics"].append(topic)
        self.memory["key_points"][topic] = extract_key_points(text)
        self.save_memory()

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

Цифры, которые вы увидите в реальности:

• Генерация текста: 15-25 токенов/секунду
• Синтез речи: 2-3x реального времени (минута речи за 20-30 секунд)
• Полный эпизод 30 минут: 45-60 минут генерации
• Потребление памяти: 10-12 ГБ VRAM в пике
• Энергопотребление: 180-220 Вт под нагрузкой

Это не мгновенно, но система работает автономно. Запустили вечером — утром 8-10 эпизодов готовы.

Что делать, если хочется большего

Базовая система работает. Но если нужно качество уровня профессиональных подкастов:

1. Добавьте RAG — подключайте базу знаний. В статье про локальный RAG-пайплайн есть готовые решения.
2. Используйте более крупные модели — Qwen2.5-14B даст лучшее качество, но потребует квантования. Или посмотрите обзор моделей для RTX 5080 — многие работают и на 5060 Ti.
3. Добавьте звуковые эффекты — джинглы, переходы, атмосферу. Python-библиотека pydub позволяет накладывать аудио.
4. Настройте несколько голосов для диалогов. XTTS поддерживает мультиязычность и разные голоса.

FAQ: вопросы, которые задают чаще всего

Можно ли запустить на ноутбуке?

Можно, но с ограничениями. Используйте квантованные 3B-модели и CPU-режим для TTS. Производительность будет в 5-10 раз ниже.

Как добавить поддержку английского языка?

В конфиге TTS поменяйте language на "en". Для LLM используйте английские промпты или мультиязычные модели типа Qwen.

Система "зацикливается" на одной теме

Это проблема температурных параметров. Увеличьте temperature до 0.8-0.9, добавьте random_seed. Или реализуйте систему "запрещенных тем" на основе памяти.

Как автоматически публиковать подкасты?

Допишите модуль для RSS-генерации и загрузки на хостинг. Используйте библиотеку feedgenerator для RSS и boto3 для S3 (если нужен облачный хостинг).

Финал: что у вас получится

Через 2-3 часа настройки вы получите систему, которая:

• Генерирует контент 24/7 без вашего участия
• Не зависит от интернета и API
• Стоит $0 в месяц (кроме электричества)
• Создает уникальный контент, которого нет больше нигде

Это не идеальная система. Иногда LLM будет генерировать странные переходы. Иногда TTS будет ошибаться в ударениях. Но это ВАША система. Вы контролируете каждый аспект, можете модифицировать, улучшать, экспериментировать.

Локальные модели — это не про "как у OpenAI, только бесплатно". Это про независимость. Про то, чтобы технологии работали на вас, а не вы подстраивались под условия SaaS-провайдеров.

Запускайте. Экспериментируйте. И когда ваша система сгенерирует первый 10-часовой подкаст-марафон, вы поймете: будущее контента не за облачными гигантами, а за теми, у кого хватило смелости собрать свое собственное производство.