Speech Synthesis / Voice Cloning

Self-host GPT-SoVITS: 5 seconds zero-shot, 1 minute to fine-tune a voice that speaks five languages

RVC-Boss/GPT-SoVITS sits at 61k+ GitHub stars under an MIT licence, and has shipped from V2 through V4 and the V2Pro/V2ProPlus line. This page does the honest VRAM arithmetic for each version, then tells you which NexGPU card to rent.

GPT-SoVITS · self-hosted

GPT-SoVITS is the fastest path from a voice sample to a usable TTS model. Hand it 5 seconds of reference audio for zero-shot synthesis, or roughly 1 minute of labelled material to fine-tune, and timbre similarity beats a lot of commercial APIs. It covers Chinese, English, Japanese, Korean and Cantonese (language codes zh / en / ja / ko / yue) and does cross-lingual inference, so a voice trained on Mandarin clips will read English lines.

Get the version lines straight first. V1/V2/V2Pro/V2ProPlus is one branch; V3/V4 is another. V3 (February 2025) raised timbre similarity and GPT stability but introduced metallic artefacts from non-integer upsampling. V4 (April 2025) fixed that by outputting native 48kHz and is positioned upstream as "a direct replacement for Version 3". V2Pro and V2ProPlus (June 2025, release tag 20250606v2pro) took a different route: they add an ERes2NetV2 speaker-verification embedding (sv/pretrained_eres2netv2w24s4ep4.ckpt, 108MB) on top of V2's hardware budget, described upstream as "slightly higher VRAM usage than v2, performance exceeding v4". V2ProPlus is still the ceiling of this project today — there is no V5.

Three things bite people who self-host. First, reference audio is hard-gated to 3–10 seconds; go outside that and inference throws "参考音频在3~10秒范围外，请更换！". Second, config.py forces float32 on Pascal cards (SM 6.1, so Tesla P40 and GTX 1080) and on the GTX 16 series, and falls back to CPU entirely below 4GB of VRAM. Third, long-text batch synthesis has a long-standing VRAM-retention problem — issue #2458 reports growth from 2G to 7G, #1519 from 2G to 29G — so a long-running API service needs headroom. Those three facts decide which card you should rent.

01 —

Versions and weights: which set to actually download

All checkpoints live in lj1995/GPT-SoVITS on HuggingFace — about 5.3GB for the full repo

Version	Parameters	VRAM	Context	Notes
V2ProPlus (20250606v2pro)	s2Gv2ProPlus.pth 200MB + s1 GPT ckpt 155MB + SV 108MB	Inference from 6GB; WebUI fine-tune batch defaults to VRAM_GB ÷ 2	24kHz native output, reference audio 3–10s	The current quality ceiling. Published RTF is 0.014 on an RTX 4090 and 0.028 on a 4060Ti — roughly 1,400 words rendered in 3.36 seconds. Also the most forgiving option when your source audio is imperfect.
V2Pro (20250606v2pro)	s2Gv2Pro.pth 162MB + s1 GPT ckpt 155MB + SV 108MB	Inference from 6GB; slightly above V2, far below V3/V4	24kHz native output, reference audio 3–10s	The value pick: keeps V2's hardware cost and inference speed while beating V4 on quality. Choose it if you want several concurrent voices on one 24GB card.
V4 (20250422v4)	s2Gv4.pth 769MB + vocoder.pth 57.8MB + s1v3.ckpt 155MB	Full fine-tune 14GB; 12GB with gradient checkpointing; 8GB with LoRA	48kHz native output, reference audio 3–10s	Kills V3's metallic artefacts and directly replaces it. Only pays off with genuinely clean 48kHz source material — on average audio it can lose to V2Pro.
V3 (20250228v3)	s2Gv3.pth 769MB + BigVGAN v2 24kHz vocoder + s1v3.ckpt 155MB	Full fine-tune 14GB; 12GB with gradient checkpointing; 8GB LoRA	24kHz output, plus a 24k→48k super-resolution model	High timbre similarity from less data, but the non-integer upsampling produces a metallic edge. Unless you have legacy checkpoints to keep, start new projects on V4.
V2 (20240821v2)	s2G2333k.pth ~106MB + s1bert25hz-5kh ckpt 155MB	Inference under 6GB; fine-tune batch = VRAM_GB ÷ 2, so 12 on a 24GB card	24kHz output	Base model extended from 2k to 5k hours, added Korean and Cantonese, rewrote the text frontend. When your dataset is messy and you want the model pulled toward the training-set average, the V2 branch beats V3/V4.

02 —

GPU selection, matched to what you are actually doing

Every NexGPU instance is metered per second and priced per hour — no minimum, no setup fee, no quota request

Zero-shot auditions and everyday V2Pro/V2ProPlus inference
RTX 3090 24GB$0.193/GPU-hr
A full V2Pro weight set is under 500MB, so 24GB holds several hot-swappable voices at once, and the 3090 is the cheapest 24GB Ampere card we rent — do not chase the Tesla P40 to save a few cents, SM 6.1 gets forced to float32 by config.py.
Few-shot fine-tune on 1 minute of audio (V2Pro / V2ProPlus, both stages)
RTX 4090 24GB$0.540/GPU-hr
The published RTF of 0.014 was measured on a 4090, and 24GB maps to the WebUI's default batch size of 12 — UVR5 separation, slicing, FunASR labelling and both training stages usually finish inside an hour.
Full V3 / V4 fine-tune (14GB documented, 12GB with checkpointing)
RTX 5090 32GB$0.723/GPU-hr
V3/V4 default their WebUI batch size to VRAM_GB ÷ 8, which is only 3 on a 24GB card. 32GB gives you 4 plus real headroom over the 14GB full fine-tune baseline, so you are not forced down to LoRA.
Long-text batch synthesis or a resident api_v2 service
RTX A6000 48GB$0.817/GPU-hr
VRAM retention on long-text inference is a known project issue (#1519 measured growth from 2G to 29G). 48GB lets the service finish an entire batch and restart cleanly instead of OOM-ing halfway.

03 —

Getting GPT-SoVITS running on NexGPU

From bare instance to api_v2 speaking, in four steps

01
Spin up the instance and install
Pick an RTX 4090 or RTX 3090 in the console and boot a PyTorch prebuilt image (we ship 2,000+ images including PyTorch, vLLM, ComfyUI and Whisper ASR). SSH in, clone the repo and run the official installer; switch --source to HF-Mirror or ModelScope if HuggingFace is slow from your region. Make sure ffmpeg is present.
```
git clone https://github.com/RVC-Boss/GPT-SoVITS.git && cd GPT-SoVITS && bash install.sh --device CU128 --source HF
```
02
Pull the pretrained weights
Everything lives in lj1995/GPT-SoVITS on HuggingFace — about 5.3GB total — and belongs under GPT_SoVITS/pretrained_models. For V2Pro/V2ProPlus confirm sv/pretrained_eres2netv2w24s4ep4.ckpt (108MB) is in place; V3 additionally needs the BigVGAN v2 24kHz vocoder, and V4 needs gsv-v4-pretrained/vocoder.pth (57.8MB). A missing vocoder only surfaces as an error at inference time.
```
huggingface-cli download lj1995/GPT-SoVITS --local-dir GPT_SoVITS/pretrained_models
```
03
Run the data pipeline and fine-tune in the WebUI
Launch the integrated WebUI (port 9874 by default; UVR5 vocal separation sits on 9873). The pipeline is: UVR5 to strip backing track and reverb, then slicing, then FunASR for Chinese or faster-whisper for other languages, then proofreading the .list annotation whose format is vocal_path|speaker_name|language|text with language codes limited to zh / ja / en / ko / yue, then train SoVITS followed by GPT. Output checkpoints land in SoVITS_weights_v2Pro and GPT_weights_v2Pro. Forward port 9874 over SSH rather than exposing it publicly.
```
python webui.py
```
04
Serve it over the API, or go straight to Docker
For production, api_v2.py listens on 9880 and exposes /tts, /control, /set_gpt_weights, /set_sovits_weights and /set_refer_audio, so you can hot-swap voices without restarting the process. Streaming inference merged in November 2025 cut first-packet latency substantially, which makes real-time conversational use practical. If you would rather skip environment setup, the official image is xxxxrt666/gpt-sovits:latest-cu128 — give it 16GB of shared memory.
```
python api_v2.py -a 0.0.0.0 -p 9880 -c GPT_SoVITS/configs/tts_infer.yaml
```

What one complete voice clone actually costs

Price it on an RTX 4090 24GB at $0.540/GPU-hr. Environment setup plus pulling 5.3GB of weights: about 0.3 hr = $0.16. UVR5 separation, slicing and FunASR labelling on one minute of source audio: about 0.2 hr = $0.11. The SoVITS and GPT fine-tuning stages: about 0.5 hr = $0.27. That caps out at 1.0 hour, or $0.54 — four voices for the price of a coffee. Inference is even cheaper: at the published V2ProPlus RTF of 0.014 on a 4090, rendering one hour of finished audio consumes 3600 × 0.014 = 50.4 seconds of GPU time, which is $0.0076. Less than a cent. Squeeze harder by running the same pipeline on an RTX 3090 24GB at $0.193/GPU-hr and the whole round costs $0.19. Keeping 8GB of weights and dataset resident is $0.414/GB-month × 8 = $3.31/month, and exporting 1GB of finished wav costs $0.0081 in egress. Remember the billing rule: compute billing stops the moment the instance stops, while storage bills until you destroy it.

04 —

FAQ

How much VRAM does GPT-SoVITS actually need to self-host?

It splits by branch. V1/V2/V2Pro/V2ProPlus are light — under 500MB of weights, inference from 6GB, and the WebUI defaults fine-tune batch size to VRAM_GB ÷ 2, so 12 on a 24GB card. V3/V4 are much heavier: the docs state 14GB for a full fine-tune, 12GB with gradient checkpointing, 8GB via LoRA, and their default batch size is VRAM_GB ÷ 8. There is also a hard floor in config.py: under 4GB of VRAM it falls back to CPU. On NexGPU, take an RTX 3090 24GB ($0.193/GPU-hr) for the first branch and an RTX 5090 32GB ($0.723/GPU-hr) for the second.

Why does my reference audio throw "参考音频在3~10秒范围外，请更换！"?

That is a hard validation, not a bug. At 16kHz the code rejects anything where wav16k.shape[0] exceeds 160000 or falls below 48000 samples — meaning the reference clip must land between 3 and 10 seconds. Trim a clean, emotionally steady segment using the slicer in the WebUI. This kind of trial-and-error is exactly what per-second billing is for: NexGPU meters by the second, so iterating until it sounds right costs pennies.

Should I pick V2Pro or V4?

It depends on your source audio. V4 outputs native 48kHz and fixes V3's metallic artefacts, but the V3/V4 branch leans harder on the reference audio, so flaws in the source get amplified, and its fine-tuning baseline is 14GB. V2Pro/V2ProPlus is described upstream as "slightly higher VRAM than v2, performance exceeding v4" while keeping V2's hardware cost and inference speed. Studio-grade material: go V4. Clips scraped off the internet: go V2ProPlus. Want to compare properly? Rent two NexGPU instances in parallel and you will know within the hour.

Can a Tesla P40, GTX 1080 or 16-series card run GPT-SoVITS?

It will run, but at reduced precision. get_device_dtype_sm() in config.py explicitly assigns float32 to SM 6.1 hardware (Pascal, including the Tesla P40 and GTX 1080) and to the GTX 16 series (SM 7.5 with a 16xx model name). No fp16 speedup, and roughly half the batch size for the same VRAM. Our Tesla P40 24GB is $0.214/GPU-hr — more than the RTX 3090's $0.193 and without fp16, which is why every recommendation on this page starts at the 3090.

VRAM climbs on long-text synthesis until it OOMs. How do I fix it?

This is a known project issue, not your environment: #2458 documents long-text inference growing from 2G to 7G, and #1519 from 2G to 29G, caused by cached text information never being released. Practical workarounds are chunking by paragraph across separate /tts calls, or restarting the api_v2 process on a schedule. The simplest fix is headroom: our RTX A6000 48GB runs $0.817/GPU-hr, and with up to 14 GPUs per node and a maximum node VRAM of 2,152GB there is plenty of room to grow into.

How much training data do I need — is one minute really enough?

Yes. The project's own tagline is "1 min voice data can also be used to train a good TTS model": 5 seconds for zero-shot, about a minute for few-shot fine-tuning, which is why it is called few-shot voice cloning. Purity matters more than volume — strip the backing track and reverb with UVR5, slice into 3–10 second segments, label with FunASR, then proofread the transcripts by hand. The whole pipeline finishes inside an hour on a NexGPU RTX 4090 ($0.540/GPU-hr), reachable via SSH, Jupyter, web terminal, REST API or CLI, with bilingual support on Telegram and no ticket queue.

Start building on NexGPU

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