Skip to main content
NexGPU

Singing voice conversion / voice cloning

Self-host so-vits-svc: training starts at 6GB of VRAM

4.1-Stable ships with batch_size 6 and fp16_run off. Rent one card, run slicing, preprocessing, training and shallow-diffusion inference end to end, and stop paying for compute the second you stop the instance.

Sign up freeView pricing

so-vits-svc is SoftVC VITS Singing Voice Conversion — singing voice conversion (SVC), not TTS. Feed it a dry vocal and it swaps the timbre while keeping the melody and articulation. The upstream repo, svc-develop-team/so-vits-svc, stops at the 4.1-Stable branch under AGPL-3.0; the author signed off with "This round of limited time update is coming to an end" and flipped the repo to read-only archive. Archived is not the same as dead: essentially every Chinese-language bundle, base model and tutorial still targets 4.1-Stable, and it remains the most reproducible route to "make this voice sing that song".

The bar is lower than the folklore suggests. The stock config_template.json uses batch_size 6, fp16_run false, sampling_rate 44100, hop_length 512, epochs 10000 and keep_ckpts 3. The widely used Chinese deployment doc asks for an NVIDIA card with at least 6GB of VRAM, at least 30GB of virtual memory, and at least 30 minutes of clean dry vocals. so-vits-svc-fork puts it even more bluntly in its README: at least 4GB of VRAM for training, at least 4GB for GPU inference. What actually drives VRAM up is not the model — it is raising batch_size, and which F0 predictor you pick during preprocessing. That same doc ranks the cost as pm >= harvest >= rmvpe ≈ fcpe >> crepe, and crepe is the one that blows up during preprocessing before you ever reach training.

The hard part was never the GPU — it is the environment. requirements.txt pins fairseq==0.12.2, numpy==1.23.5, librosa==0.9.1 and scipy==1.10.0, and the project only claims stability on Python 3.8.9. Installing fairseq on 3.11 fails almost every time, which is exactly why so-vits-svc-fork dropped the fairseq dependency entirely. A project that is painful to install once and untouched afterwards is the ideal candidate for a per-second-billed cloud GPU: boot an instance from a PyTorch image, install, train, pull down your G_*.pth, and compute billing stops when the instance does. One legal fact worth repeating, because it comes from the repo and not from us: the upstream Terms of Use state the project is for academic purposes only and not for production deployment, require you to credit the original source vocal when you publish a conversion, and place full responsibility for dataset authorisation on you.

01 —

Versions and branches: which one you are actually installing

Four mutually incompatible codebases share the so-vits-svc name, and none of their checkpoints interchange

VersionParametersVRAMContextNotes
so-vits-svc 4.1-Stable (svc-develop-team, AGPL-3.0)vec768l12 encoder · ssl_dim 768 · gin_channels 768 · inter/hidden 192 · n_speakers 200Training ≥6GB (stock batch_size 6, fp16_run false); GPU inference comfortable at 4GB class44100Hz mono, 5–15s training slices; hop_length 512, upsample_rates [8,8,2,2,2]The de facto mainline. Shallow diffusion, k-means clustering, feature retrieval and loudness embedding (--vol_aug) all live here, and the community base models target it. Repo is read-only archived, but the code still runs.
so-vits-svc 4.0 series (legacy)vec256l9 encoder · ssl_dim 256, no shallow diffusion or feature retrievalSame class as 4.1, marginally lighter thanks to the smaller encoder dimension44100Hz monoThe only reason to care: you have a G_*.pth from the 4.0 era. 4.0 and 4.1 checkpoints are not interchangeable — old models must stay on old code, no amount of repo-swapping will load them.
so-vits-svc-fork v1.3.2 (voicepaw / 34j, MIT + Apache-2.0)4.0 architecture, packaged on PyPI as so-vits-svc-fork, no fairseq dependencyREADME is explicit: at least 4GB of VRAM to train, at least 4GB for GPU inference44100Hz; realtime conversion runs in blocks with crossfadeEasiest install by far: pip install -U so-vits-svc-fork, runs on Python 3.11, ships a GUI (svcg) and realtime mic conversion (svc vc), and auto-downloads pretrained models. The README now reads "No Longer Maintained" and points at the RVC family, VCClient and yxlllc/DDSP-SVC.
so-vits-svc 5.0 = PlayVoice/whisper-vits-svc (MIT)Whisper-PPG content encoding + HuBERT-soft + Google speaker encoder + BigVGAN vocoderStates a 6GB minimum for training; batch_size 6 on 6GB, 8 works but each step is much slowerPreprocessing runs at both 16k and 32k; crepe for pitch extractionCarries the 5.0 label but shares no code or weights with 4.x. Best audio quality lives on the bigvgan-mix-v2 branch. Its pitch is noise immunity and timbre-leakage suppression via data perturbation, a MIX encoder and USP inference.
4.1 + shallow diffusion (optional add-on)Diffusion head n_layers 20 / n_chans 512 / n_hidden 256, timesteps 1000, k_step_max 0diffusion_template defaults to batch_size 48, amp_dtype fp32, cache_all_data pinned to CPU memoryblock_size 512, training slice duration 2s (must be shorter than your shortest training clip)Enabled at inference with -shd, step count via -ks (default 100). This is the standard fix for 4.1's dull highs and sibilance, and it needs the NSF-HiFiGAN vocoder (nsf_hifigan_20221211.zip).

02 —

Picking a NexGPU card for the job you actually have

so-vits-svc trains in fp32 by default (fp16_run false), which makes big-VRAM older silicon unusually good value here

  • Inference only: convert a track to a target voice, with -shd shallow diffusion and the -eh enhancer on

    RTX 3090 24GB$0.193/GPU-hour

    A 4GB job on a 24GB card means crepe F0, shallow diffusion and the NSF-HiFiGAN enhancer can all run at once without meeting torch.cuda.OutOfMemoryError.

  • Single-speaker training: 30–60 minutes of dry vocals, batch_size pushed above the stock 6

    RTX 4090 24GB$0.540/GPU-hour

    With fp32 training the bottleneck is step time, not memory, and the 4090's fp32 throughput turns "a few hundred epochs" from an overnight job into an afternoon.

  • Long unattended training runs where hourly cost is the only thing you are optimising

    Tesla V100 32GB$0.188/GPU-hour

    fp16_run is off by default, so Volta gives up nothing on pure fp32 training, 32GB buys headroom over the usual 24GB cards, and it is the cheapest card on the platform.

  • Multi-speaker datasets, or switching to the whisper-ppg-large / cnhubertlarge encoders

    RTX A6000 48GB$0.817/GPU-hour

    The large encoders are memory-hungry inside preprocess_hubert_f0.py itself, and raising n_speakers keeps batch sizes up — 48GB lets you preprocess in one pass instead of restarting in chunks.

03 —

Empty instance to audible output, in four steps

Against 4.1-Stable; every command below is a script and flag that actually exists in the repo

  1. 01

    Boot the instance and pin the Python version

    Start from a PyTorch image, then drop the environment to Python 3.8–3.10. requirements.txt pins fairseq==0.12.2 and numpy==1.23.5; there is no usable fairseq wheel for 3.11 and building from source almost always fails. This is the first wall nearly everyone hits. Preprocessing and all_in_mem also eat host RAM — the deployment doc asks for 30GB+ of virtual memory, so glance at the node's RAM when you pick one.

    conda create -n sovits python=3.10 -y && conda activate sovits && pip install -r requirements.txt
  2. 02

    Drop in the pretrained encoders, lay out the dataset, preprocess

    Put ContentVec's checkpoint_best_legacy_500.pt (or hubert_base.pt, ~181MB) into pretrain/. Add nsf_hifigan_20221211.zip if you want shallow diffusion, and rmvpe.pt (~173MB) if you want the RMVPE pitch predictor. Lay out dry vocals as dataset_raw/speaker_name/xxx.wav, sliced to 5–15 seconds, at least 30 minutes total; with the whisper-ppg encoder no clip may exceed 30 seconds. Then run the three stages: resample to 44.1kHz mono, generate config.json and the training lists, extract HuBERT features and F0.

    python resample.py && python preprocess_flist_config.py --speech_encoder vec768l12 --vol_aug && python preprocess_hubert_f0.py --f0_predictor rmvpe --use_diff --num_processes 8
  3. 03

    Train, and size batch_size to the card

    batch_size in config.json is the one knob that reliably changes VRAM use; stock is 6. Lower it if you OOM, raise it if the card is idling. If disk I/O becomes the bottleneck, flip all_in_mem on to hold the dataset in RAM. epochs defaults to 10000, but that is an upper bound nobody reaches — a few hundred epochs typically produces usable results, so watch TensorBoard and stop by hand. keep_ckpts defaults to keeping only the last 3 checkpoints. Train the diffusion head separately if you want shallow diffusion.

    python train.py -c configs/config.json -m 44k   # optional: python train_diff.py -c configs/diffusion.yaml
  4. 04

    Infer, with the right switches turned off

    The critical one: never pass -a (auto_predict_f0) when converting singing — it is meant for speech and it will detune your vocal. -t shifts pitch in semitones, -f0p set to rmvpe or fcpe is usually steadier than the default pm, -sd defaults to -40 and should go to -30 on noisy source, -ns affects articulation clarity, -shd enables shallow diffusion and -ks sets its step count. For timbre leakage, attach a cluster or feature-retrieval model: -cm for the path, -cr for a 0–1 blend ratio.

    python inference_main.py -m logs/44k/G_30400.pth -c configs/config.json -n input.wav -t 0 -s speaker_name -f0p rmvpe -shd -ks 100

What one finished voice actually costs

Take a realistic run: 45 minutes of dry vocals, one speaker, 4.1-Stable plus shallow diffusion. Preprocessing (resample + flist + rmvpe feature extraction across 8 processes) takes roughly 0.5 hours, training runs 12 hours, and another hour goes to inference tuning and listening — 13.5 hours total. On an RTX 4090 24GB: 13.5 × $0.540 = $7.29. On an RTX 3090 24GB: 13.5 × $0.193 = $2.61. Grinding it out on a Tesla V100 32GB: 13.5 × $0.188 = $2.54. Storage is separate: 50GB for raw vocals, slices and checkpoints at $0.414/GB-month is about $0.69 per day, so $1.38 across two days; pulling the finished model home is 0.3GB of egress × $0.0081 ≈ $0.002. That lands the 4090 route at roughly $8.67 and the 3090 route at about $4.00. Everything is metered per second and priced per hour, with no minimum and no setup fee. Compute billing stops when the instance stops — storage keeps running until you destroy the volume, so delete the dataset volume when you are done.

04 —

FAQ

How much VRAM does so-vits-svc actually need? Can a 4GB card train it?

so-vits-svc-fork's README states 4GB of VRAM for both training and GPU inference. The mainline 4.1 deployment doc asks for 6GB or more, because the stock config uses batch_size 6. So yes, 4GB can train — but you have almost no room to tune, and preprocessing with crepe as the F0 predictor will usually OOM first. The honest advice is not to economise here. On NexGPU an RTX 3090 24GB is $0.193/GPU-hour and a Tesla V100 32GB is $0.188/GPU-hour, so setting batch_size somewhere comfortable costs less than rerunning preprocessing twice.

Is so-vits-svc still maintained? Is it still worth using?

Upstream svc-develop-team/so-vits-svc was archived read-only in November 2023 at 4.1-Stable, and so-vits-svc-fork's README now opens with "No Longer Maintained" and points readers at the RVC family (including IAHispano/Applio), VCClient and yxlllc/DDSP-SVC. But nothing is broken: the base models, bundles and tutorials are all still there, and plenty of people still think 4.1's singing output is worth the install pain. The way to decide is to run the same dry vocal through 4.1 and through RVC and judge with your ears, not with star counts. NexGPU's 2,000+ prebuilt images include ready PyTorch environments, so you can start installing the moment the instance boots.

How much training data does so-vits-svc need, and how many epochs?

The deployment doc's floor is at least 30 minutes of clean dry vocals, more is better, cut into 5–15 second clips (no clip over 30 seconds if you use the whisper-ppg encoder). The config's epochs value of 10000 is an upper bound nobody reaches; in practice a few hundred epochs gives usable results and you stop it manually from TensorBoard. Data quality dominates quantity — badly separated backing tracks, breath noise and room reverb cannot be trained away. At 12 hours of training a full pass on an RTX 4090 24GB is $6.48, cheap enough to try two or three versions of the dataset.

Why does pip install fail on fairseq? Why does numpy keep erroring?

This is so-vits-svc's most famous trap. requirements.txt pins fairseq==0.12.2 and numpy==1.23.5, fairseq 0.12.2 has no prebuilt wheel for Python 3.11, and building it from source is very sensitive to your toolchain. The project only guarantees stability on Python 3.8.9. Two ways out: drop back to Python 3.8–3.10 and install mainline, or use so-vits-svc-fork, which removed the fairseq dependency entirely — pip install -U so-vits-svc-fork, works on 3.11. On NexGPU this problem gets cheaper: if you wreck the environment, destroy the instance and boot a clean one in seconds instead of gambling with your local conda.

The converted vocal is off-key, robotic, or leaking the source timbre — what do I change?

Work down the list. One: never pass -a (auto_predict_f0) for singing; it is a speech-conversion switch and it will detune you. Two: change -f0p from the default pm to rmvpe or fcpe — crepe sounds good but is the heaviest on VRAM. Three: on noisy source move -sd from -40 to -30, then tune -ns for articulation clarity. Four: for timbre leakage attach a cluster or feature-retrieval model with -cm and blend it with -cr between 0 and 1; retrieval articulates better but infers slower. Five: if the highs and sibilance sound muffled, turn on shallow diffusion with -shd and tune -ks. These are all inference-side flags, so each attempt is quick — keeping an RTX 3090 running at $0.193/GPU-hour on NexGPU while you iterate beats tying up your own card.

so-vits-svc vs RVC vs DDSP-SVC — which should I pick?

They target different things. so-vits-svc 4.1 has the deepest ecosystem in singing conversion and the most knobs (clustering, feature retrieval, shallow diffusion, multiple encoders), at the cost of a painful install and heavy training. RVC is built for small datasets — it claims a usable model from roughly 10 minutes of voice data and uses Top-1 retrieval to suppress timbre leakage, and it is still actively developed. DDSP-SVC 6.3 (MIT) positions itself openly as the lightweight option, stating hardware consumption significantly lower than so-vits-svc at training speeds close to RVC. For realtime voice changing, w-okada/voice-changer supports RVC, so-vits-svc, DDSP-SVC and Beatrice side by side. The sane move is to run the same dry vocal through all three — NexGPU spans 51 countries and regions, 1,175 verified rentable nodes and 75 GPU models with per-second metering and no minimum, so spinning up three instances in parallel may well cost less than a week of deliberating.

More in Voice cloning and conversion

Every model guide

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.

Sign up freeTalk to sales

Sign up to browse live network pricing. No payment method required.