RVC वॉइस क्लोन

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

Retrieval-based Voice Conversion का उपयोग करके आवाज़ों को क्लोन और परिवर्तित करें।

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

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

देखें CLORE.AI मार्केटप्लेस
GPU प्रकार, VRAM और कीमत के अनुसार फ़िल्टर करें
चुनें ऑन-डिमांड (नियत दर) या स्पॉट (बोली मूल्य)
अपना ऑर्डर कॉन्फ़िगर करें:
- Docker इमेज चुनें
- पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)
- आवश्यक होने पर environment variables जोड़ें
- स्टार्टअप कमांड दर्ज करें
भुगतान चुनें: CLORE, BTC, या USDT/USDC
ऑर्डर बनाएं और डिप्लॉयमेंट की प्रतीक्षा करें

अपना सर्वर एक्सेस करें

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

RVC क्या है?

RVC (Retrieval-based Voice Conversion) कर सकता है:

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

आवश्यकताएँ

कार्य

न्यूनतम VRAM

अनुशंसित

इन्फरेंस

4GB

RTX 3060

ट्रेनिंग

8GB

RTX 3090

रीयल-टाइम

6GB

RTX 3070

त्वरित डिप्लॉय

Docker इमेज:

pytorch/pytorch:2.11.0-cuda12.8-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 यहाँ खोजें मेरे ऑर्डर:

जाएँ मेरे ऑर्डर पेज पर
अपने ऑर्डर पर क्लिक करें
ढूँढें 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 का उपयोग करके

खोलें http://<proxy>:7865
"Model Inference" टैब पर जाएँ
ऑडियो फ़ाइल अपलोड करें
आवाज़ मॉडल चुनें
सेटिंग्स समायोजित करें
"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)

कस्टम आवाज़ को ट्रेन करना

डेटासेट तैयार करें

10-30 मिनट का साफ़ ऑडियो इकट्ठा करें
इसे 5-15 सेकंड के क्लिप्स में काटें
बैकग्राउंड शोर/संगीत हटाएँ


# ऑडियो को क्लिप्स में विभाजित करें
ffmpeg -i full_audio.mp3 -f segment -segment_time 10 -c copy clips/clip_%03d.mp3

वेब UI के माध्यम से ट्रेन करें

"Train" टैब पर जाएँ
एक्सपेरिमेंट का नाम दर्ज करें
ट्रेनिंग फ़ोल्डर पथ सेट करें
"Process data" पर क्लिक करें
"Feature extraction" पर क्लिक करें
"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 विधियाँ

विधि

गुणवत्ता

गति

सबसे उपयुक्त

ठीक

तेज़

परीक्षण

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

~5 सेकंड

ट्रेनिंग (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 मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

का उपयोग करें स्पॉट रुक-रुक कर किए जाने वाले कार्य के लिए बाज़ार — लगभग एक-तिहाई सर्वर स्पॉट कीमत को ऑन-डिमांड से नीचे रखते हैं (मध्य मान ~13% छूट), बाकी इसे समान रखते हैं
के साथ भुगतान करें CLORE टोकन
विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

अगले चरण

Bark TTS - पाठ-से-वाक्
AudioCraft Music - संगीत निर्माण
Whisper प्रतिलेखन - वाक्-से-पाठ

पिछलाOpenVoice

अगलाDemucs पृथक्करण

अंतिम अपडेट 12 दिन पहले

क्या यह उपयोगी था?