RVC वॉइस क्लोन

Clore.ai GPUs पर RVC के साथ वॉइस क्लोन और कन्वर्ट करें

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

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें के माध्यम से किराये पर लिया जा सकता है CLORE.AI मार्केटप्लेस.

CLORE.AI पर किराया लेना

1. दिखें CLORE.AI मार्केटप्लेस

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

कमांड:

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 नीचे दिए उदाहरणों में।

इंस्टॉलेशन

# रिपॉज़िटरी क्लोन करें
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

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. पृष्ठभूमि शोर/संगीत हटाएँ

# ऑडियो को क्लिप्स में विभाजित करें
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" पर क्लिक करें

कमांड लाइन के माध्यम से प्रशिक्षण

# चरण 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	सर्वोत्तम	मध्यम	सभी

रीयल-टाइम कन्वर्शन

सेटअप

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 में कनवर्ट करें

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"}}
)

ऑडियो प्रीप्रोसेसिंग

शोर हटाएँ

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)

वॉल्यूम सामान्यीकृत करें

from pydub import AudioSegment

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

मौनता हटाएँ

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

बैच प्रोसेसिंग

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}")

सिंगिंग वॉयस कन्वर्शन

गीतों के लिए, उपयुक्त सेटिंग्स का उपयोग करें:

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 सर्वर

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 मार्केटप्लेस ।

पैसा बचाएँ:

• उपयोग करें स्पॉट लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)

• भुगतान करें CLORE टोकन के साथ

• विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

अगले कदम

• Bark TTS - टेक्स्ट-टू-स्पीच

• AudioCraft म्यूजिक - म्यूजिक जनरेशन

• Whisper ट्रांसक्रिप्शन - स्पीच-टू-टेक्स्ट