# Клонирование голоса 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](/guides/guides_v2-ru/audio-i-golos/bark-tts.md) - Синтез речи (text-to-speech)
* [AudioCraft Music](/guides/guides_v2-ru/audio-i-golos/audiocraft-music.md) - Генерация музыки
* [Whisper Transcription](/guides/guides_v2-ru/audio-i-golos/whisper-transcription.md) - Распознавание речи (speech-to-text)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/audio-i-golos/rvc-voice-clone.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.