> 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-hi/audio-and-voice/rvc-voice-clone.md).

# RVC Voice Clone

रिकवरी-आधारित वॉयस कन्वर्शन का उपयोग करके वॉयस क्लोन और कनवर्ट करें।

{% 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 इमेज चुनें
   * पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)
   * आवश्यक होने पर पर्यावरण चर जोड़ें
   * स्टार्टअप कमांड दर्ज करें
5. भुगतान चुनें: **CLORE**, **BTC**, या **USDT/USDC**
6. ऑर्डर बनाएं और डिप्लॉयमेंट की प्रतीक्षा करें

### अपने सर्वर तक पहुँचें

* कनेक्शन विवरण में खोजें **मेरे ऑर्डर**
* वेब इंटरफेस: HTTP पोर्ट URL का उपयोग करें
* SSH: `ssh -p <port> root@<proxy-address>`

## RVC क्या है?

RVC (रिकवरी-आधारित वॉयस कन्वर्शन) कर सकता है:

* न्यूनतम प्रशिक्षण के साथ किसी भी आवाज़ को क्लोन करें
* गायन/बोलने वाली आवाज़ों को कनवर्ट करें
* रीयल-टाइम वॉयस कन्वर्शन
* उच्च-गुणवत्ता आउटपुट

## आवश्यकताएँ

| टास्क     | न्यूनतम VRAM | अनुशंसित |
| --------- | ------------ | -------- |
| इनफेरेन्स | 4GB          | RTX 3060 |
| प्रशिक्षण | 8GB          | RTX 3090 |
| रीयल-टाइम | 6GB          | 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
```

## वॉयस कन्वर्शन (इनफेरेन्स)

### वेब 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
```

### वेब 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"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 समायोजित करें
* rmvpe f0 विधि का उपयोग करें
* प्रशिक्षण डेटा में सुसंगत पिच सुनिश्चित करें

### ऑडियो गुणवत्ता

* 48kHz सैंपल रेट का उपयोग करें
* प्रशिक्षण डेटा से पृष्ठभूमि शोर हटाएँ
* अधिक एपॉच के लिए ट्रेन करें

## 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 बैच आकार का उपयोग करें
* मिक्स्ड प्रिसिशन सक्षम करें
* डेटासेट के लिए NVMe SSD का उपयोग करें

## प्रदर्शन

| टास्क                       | GPU      | समय         |
| --------------------------- | -------- | ----------- |
| इनफेरेन्स (1 मिनट ऑडियो)    | RTX 3090 | \~5s        |
| प्रशिक्षण (30 मिनट डेटासेट) | RTX 3090 | \~2 घंटे    |
| रीयल-टाइम कन्वर्शन          | RTX 3070 | <50ms विलंब |

## समस्या निवारण

## लागत का अनुमान

सामान्य 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) *।*

**पैसा बचाएँ:**

* उपयोग करें **स्पॉट** लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)
* भुगतान करें **CLORE** टोकन के साथ
* विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

## अगले कदम

* [Bark TTS](/guides/guides_v2-hi/audio-and-voice/bark-tts.md) - टेक्स्ट-टू-स्पीच
* [AudioCraft म्यूजिक](/guides/guides_v2-hi/audio-and-voice/audiocraft-music.md) - म्यूजिक जनरेशन
* [Whisper ट्रांसक्रिप्शन](/guides/guides_v2-hi/audio-and-voice/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-hi/audio-and-voice/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.