> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-ru/audio-i-golos/rvc-voice-clone.md).

# Клонирование голоса RVC

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

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

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

1. Перейдите [маркетплейс CLORE.AI](https://clore.ai/marketplace)
2. Отфильтруйте по типу GPU, объёму VRAM и цене
3. Выберите **По требованию** (фиксированная ставка) или **Спот** (цена ставки)
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 | Рекомендуется |
| ------------------ | --------- | ------------- |
| Инференс           | 4 ГБ      | RTX 3060      |
| Обучение           | 8 ГБ      | RTX 3090      |
| В реальном времени | 6 ГБ      | RTX 3070      |

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

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

```
pytorch/pytorch:2.11.0-cuda12.8-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
```

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

### Используя Web UI

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
```

### Обучение через Web UI

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"
```

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

| Параметр              | Описание                  | Рекомендуется |
| --------------------- | ------------------------- | ------------- |
| Частота дискретизации | Качество аудио            | 48000         |
| Размер батча          | Пакет обучения            | 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"Преобразовано: {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
* Включите смешанную точность
* Используйте SSD NVMe для набора данных

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

| Задача                            | GPU      | Время           |
| --------------------------------- | -------- | --------------- |
| Инференс (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*](https://clore.ai/marketplace) *текущие тарифы.*

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

* Используйте **Спот** рынок для прерываемых задач — примерно треть серверов оценивает spot ниже on-demand (медиана \~13% скидки), остальные совпадают с ним
* Платите **CLORE** токенами
* Сравните цены у разных провайдеров

## Дальнейшие шаги

* [Bark TTS](/guides/guides_v2-ru/audio-i-golos/bark-tts.md) - преобразование текста в речь
* [AudioCraft Music](/guides/guides_v2-ru/audio-i-golos/audiocraft-music.md) - генерация музыки
* [Whisper Transcription](/guides/guides_v2-ru/audio-i-golos/whisper-transcription.md) - преобразование речи в текст


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.