# Клон голоса RVC

Клонируйте и превращайте голоса с помощью преобразования голоса на основе поиска (Retrieval-based Voice Conversion).

{% hint style="success" %}
Все примеры можно запустить на GPU-серверах, арендуемых через [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Аренда на CLORE.AI

1. Посетите [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Фильтровать по типу GPU, объёму видеопамяти и цене
3. Выберите **По требованию** (фиксированная ставка) или **Spot** (цена заявки)
4. Настройте ваш заказ:
   * Выберите Docker-образ
   * Укажите порты (TCP для SSH, HTTP для веб-интерфейсов)
   * При необходимости добавьте переменные окружения
   * Введите команду запуска
5. Выберите способ оплаты: **CLORE**, **BTC**, или **USDT/USDC**
6. Создайте заказ и дождитесь развертывания

### Доступ к вашему серверу

* Найдите данные для подключения в **Мои заказы**
* Веб-интерфейсы: используйте URL HTTP-порта
* SSH: `ssh -p <port> root@<proxy-address>`

## Что такое RVC?

RVC (Retrieval-based Voice Conversion) может:

* Клонировать любой голос с минимальным обучением
* Преобразовывать пение/речь
* Преобразование голоса в реальном времени
* Высокое качество вывода

## Требования

| Задача            | Мин. VRAM | Рекомендуется |
| ----------------- | --------- | ------------- |
| Вывод (Inference) | 4 ГБ      | RTX 3060      |
| Обучение          | 8 ГБ      | RTX 3090      |
| Реальное время    | 6 ГБ      | RTX 3070      |

## Быстрое развертывание

**Docker-образ:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel
```

**Порты:**

```
22/tcp
7865/http
```

**Команда:**

```bash
apt-get update && apt-get install -y ffmpeg git && \
cd /workspace && \
git clone https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI.git && \
cd Retrieval-based-Voice-Conversion-WebUI && \
pip install -r requirements.txt && \
python infer-web.py --host 0.0.0.0 --port 7865
```

## Доступ к вашему сервису

После развертывания найдите ваш `http_pub` URL в **Мои заказы**:

1. Перейдите на **Мои заказы** страницу
2. Кликните по вашему заказу
3. Найдите `http_pub` URL (например, `abc123.clorecloud.net`)

Используйте `https://YOUR_HTTP_PUB_URL` вместо `localhost` в примерах ниже.

## Установка

```bash

# Клонировать репозиторий
git clone https://github.com/RVC-Project/Retrieval-based-Voice-Conversion-WebUI.git
cd Retrieval-based-Voice-Conversion-WebUI

# Установить зависимости
pip install -r requirements.txt

# Скачайте модели
python tools/download_models.py
```

## Преобразование голоса (Inference)

### Использование веб-интерфейса

1. Откройте `http://<proxy>:7865`
2. Перейдите на вкладку «Model Inference»
3. Загрузите аудиофайл
4. Выберите модель голоса
5. Настройте параметры
6. Нажмите «Convert»

### Python API

```python
from infer_pack.models import SynthesizerTrnMs256NSFsid, SynthesizerTrnMs768NSFsid
from vc_infer_pipeline import VC
import torch
import soundfile as sf

# Загрузить модель
model_path = "./models/my_voice.pth"
index_path = "./models/my_voice.index"

vc = VC(
    model_path=model_path,
    config_path="./configs/v2/48k.json",
    device="cuda"
)

# Преобразовать аудио
audio, sr = sf.read("input.wav")
output = vc.convert(
    audio=audio,
    f0_method="rmvpe",  # Метод извлечения высоты тона
    index_path=index_path,
    index_rate=0.75,
    f0_up_key=0,  # Сдвиг высоты тона (в полутонах)
    protect=0.33
)

sf.write("output.wav", output, sr)
```

## Обучение пользовательского голоса

### Подготовить датасет

1. Соберите 10–30 минут чистого аудио
2. Нарежьте на клипы по 5–15 секунд
3. Удалите фоновый шум/музыку

```bash

# Разделить аудио на клипы
ffmpeg -i full_audio.mp3 -f segment -segment_time 10 -c copy clips/clip_%03d.mp3
```

### Обучение через веб-интерфейс

1. Перейдите на вкладку «Train»
2. Введите название эксперимента
3. Установите путь к папке с обучением
4. Нажмите «Process data»
5. Нажмите «Feature extraction»
6. Нажмите «Train»

### Обучение через командную строку

```bash

# Шаг 1: Обработать аудио
python trainset_preprocess_pipeline_print.py \
    "./dataset" \
    48000 \
    8 \
    "./logs/experiment" \
    False

# Шаг 2: Извлечь признаки
python extract_f0_print.py \
    "./logs/experiment" \
    8 \
    "rmvpe"

python extract_feature_print.py \
    "cuda:0" \
    "1" \
    "0" \
    "0" \
    "./logs/experiment" \
    "v2"

# Шаг 3: Обучение
python train_nsf_sim_cache_sid_load_pretrain.py \
    -e "experiment" \
    -sr "48k" \
    -f0 1 \
    -bs 8 \
    -g 0 \
    -te 200 \
    -se 20 \
    -pg "./pretrained/f0G48k.pth" \
    -pd "./pretrained/f0D48k.pth" \
    -l 0 \
    -c 1 \
    -sw 0 \
    -v "v2"
```

## Параметры обучения

| Параметр                            | Описание                             | Рекомендуется |
| ----------------------------------- | ------------------------------------ | ------------- |
| Частота дискретизации (Sample Rate) | Качество аудио                       | 48000         |
| Размер батча (Batch Size)           | Пакет обучения                       | 8-16          |
| Эпохи                               | Итерации обучения                    | 200-500       |
| Сохранять каждые                    | Частота сохранения контрольных точек | 20-50         |
| Метод f0                            | Извлечение высоты тона               | rmvpe         |

## Методы F0

| Метод   | Качество | Скорость | Лучше всего для |
| ------- | -------- | -------- | --------------- |
| pm      | ОК       | Быстро   | Тестирование    |
| harvest | Хорошо   | Медленно | Общее           |
| crepe   | Отлично  | Средне   | Пение           |
| rmvpe   | Лучшее   | Средне   | Все             |

## Преобразование в реальном времени

### Настройка

```python
import pyaudio
import numpy as np
from infer_pack.models import SynthesizerTrnMs256NSFsid
from vc_infer_pipeline import VC

# Инициализация
vc = VC(model_path="./models/voice.pth", device="cuda")

# Настройка аудио
CHUNK = 1024
FORMAT = pyaudio.paFloat32
CHANNELS = 1
RATE = 48000

p = pyaudio.PyAudio()
stream_in = p.open(format=FORMAT, channels=CHANNELS, rate=RATE,
                   input=True, frames_per_buffer=CHUNK)
stream_out = p.open(format=FORMAT, channels=CHANNELS, rate=RATE,
                    output=True, frames_per_buffer=CHUNK)

# Цикл в реальном времени
while True:
    audio_in = np.frombuffer(stream_in.read(CHUNK), dtype=np.float32)
    audio_out = vc.convert(audio_in)
    stream_out.write(audio_out.tobytes())
```

## Форматы моделей

### Конвертация в ONNX

```python
import torch

# Загрузить модель PyTorch
model = torch.load("model.pth")

# Экспорт в ONNX
torch.onnx.export(
    model,
    dummy_input,
    "model.onnx",
    input_names=["audio"],
    output_names=["converted"],
    dynamic_axes={"audio": {0: "length"}}
)
```

## Предобработка аудио

### Удаление шума

```python
import noisereduce as nr
import soundfile as sf

audio, sr = sf.read("noisy.wav")
reduced_noise = nr.reduce_noise(y=audio, sr=sr)
sf.write("clean.wav", reduced_noise, sr)
```

### Нормализация громкости

```python
from pydub import AudioSegment

audio = AudioSegment.from_wav("input.wav")
normalized = audio.normalize()
normalized.export("normalized.wav", format="wav")
```

### Удаление тишины

```python
from pydub import AudioSegment
from pydub.silence import split_on_silence

audio = AudioSegment.from_wav("input.wav")
chunks = split_on_silence(audio, min_silence_len=500, silence_thresh=-40)
combined = sum(chunks)
combined.export("no_silence.wav", format="wav")
```

## Пакетная обработка

```python
import os
from vc_infer_pipeline import VC
import soundfile as sf

vc = VC(model_path="./models/voice.pth", device="cuda")

input_dir = "./inputs"
output_dir = "./outputs"
os.makedirs(output_dir, exist_ok=True)

for filename in os.listdir(input_dir):
    if filename.endswith(('.wav', '.mp3', '.flac')):
        input_path = os.path.join(input_dir, filename)
        output_path = os.path.join(output_dir, f"converted_{filename}")

        audio, sr = sf.read(input_path)
        converted = vc.convert(audio)
        sf.write(output_path, converted, sr)

        print(f"Converted: {filename}")
```

## Преобразование голосового пения

Для песен используйте подходящие настройки:

```python
output = vc.convert(
    audio=audio,
    f0_method="rmvpe",  # Лучше всего для пения
    index_rate=0.5,     # Меньше для пения
    f0_up_key=-2,       # Настройте высоту тона для соответствия
    protect=0.5         # Защита согласных
)
```

## Распространённые проблемы

### Голос звучит роботизированно

* Используйте исходное аудио более высокого качества
* Увеличьте значение protect (0.4–0.5)
* Попробуйте другой метод f0

### Проблемы с тоном

* Отрегулируйте f0\_up\_key
* Используйте метод f0 rmvpe
* Обеспечьте согласованность тона в тренировочных данных

### Качество аудио

* Используйте частоту дискретизации 48 кГц
* Удалите фоновый шум из тренировочных данных
* Обучайте дольше (больше эпох)

## API-сервер

```python
from fastapi import FastAPI, UploadFile
from fastapi.responses import FileResponse
from vc_infer_pipeline import VC
import soundfile as sf
import tempfile

app = FastAPI()
vc = VC(model_path="./models/voice.pth", device="cuda")

@app.post("/convert")
async def convert_voice(file: UploadFile, pitch: int = 0):
    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_in:
        content = await file.read()
        tmp_in.write(content)
        tmp_in_path = tmp_in.name

    audio, sr = sf.read(tmp_in_path)
    converted = vc.convert(audio, f0_up_key=pitch)

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_out:
        sf.write(tmp_out.name, converted, sr)
        return FileResponse(tmp_out.name, media_type="audio/wav")
```

## Советы по обучению

### Для лучшего качества

* Используйте более 20 минут чистого аудио
* Удалите весь фоновый шум
* Единообразная настройка микрофона/записи
* Включите разнообразные выражения/эмоции

### Для более быстрого обучения

* Используйте размер батча 8–16
* Включите смешанную точность (mixed precision)
* Используйте NVMe SSD для датасета

## Производительность

| Задача                            | GPU      | Время           |
| --------------------------------- | -------- | --------------- |
| Вывод (Inference) (1 мин аудио)   | RTX 3090 | \~5 с           |
| Обучение (датасет 30 мин)         | RTX 3090 | \~2 часа        |
| Преобразование в реальном времени | RTX 3070 | Задержка <50 мс |

## Устранение неполадок

## Оценка стоимости

Типичные тарифы на маркетплейсе CLORE.AI (по состоянию на 2024):

| GPU       | Почасовая ставка | Дневная ставка | Сессия 4 часа |
| --------- | ---------------- | -------------- | ------------- |
| RTX 3060  | \~$0.03          | \~$0.70        | \~$0.12       |
| RTX 3090  | \~$0.06          | \~$1.50        | \~$0.25       |
| RTX 4090  | \~$0.10          | \~$2.30        | \~$0.40       |
| A100 40GB | \~$0.17          | \~$4.00        | \~$0.70       |
| A100 80GB | \~$0.25          | \~$6.00        | \~$1.00       |

*Цены варьируются в зависимости от провайдера и спроса. Проверьте* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *для текущих тарифов.*

**Экономьте деньги:**

* Используйте **Spot** рынок для гибких рабочих нагрузок (часто на 30–50% дешевле)
* Платите с помощью **CLORE** токенов
* Сравнивайте цены разных провайдеров

## Следующие шаги

* [Bark TTS](https://docs.clore.ai/guides/guides_v2-ru/audio-i-golos/bark-tts) - Синтез речи (text-to-speech)
* [AudioCraft Music](https://docs.clore.ai/guides/guides_v2-ru/audio-i-golos/audiocraft-music) - Генерация музыки
* [Whisper Transcription](https://docs.clore.ai/guides/guides_v2-ru/audio-i-golos/whisper-transcription) - Распознавание речи (speech-to-text)