How do I train an RVC voice model with Applio on a cloud GPU?

Cover: Train an RVC voice model with Applio on a cloud GPU, run-install.sh, python core.py train --gpu 0

Deploy a Raw GPU instance, clone Applio from GitHub, run bash run-install.sh, upload your recordings to assets/datasets/<name>, and either train in the Applio web UI through an SSH tunnel to port 6969 or run python core.py preprocess, extract, train and index inside tmux, then copy the exported .pth and .index off before you destroy the instance.

Updated 2026-10-30

This guide follows the official Applio documentation (Install Applio, Train a voice model, Command-line interface, Run Applio in the cloud) and the scripts in the Applio GitHub repository, all read on 2026-10-30. The latest Applio release on GitHub that day was 3.7.1. It is for voice and music creators who want to train an RVC voice model on a rented NVIDIA GPU such as the RTX 5090 or the other cards listed on /pricing.

Only train on recordings you own or have explicit permission to use. Applio’s Terms of Use ask you to respect copyright, intellectual property and privacy rights, and prohibit audio made to defame, harm, manipulate or deceive others. The code is under the MIT license.

What you need

Item Official value (read 2026-10-30) Source
Install on Linux git clone https://github.com/IAHispano/Applio.git, bash run-install.sh, bash run-applio.sh Applio docs, Install Applio
Python “Current scripts target Python 3.12” (the install script creates it with uv) Applio docs, Install Applio; run-install.sh
PyTorch torch==2.11.0, installed from the PyTorch cu128 wheel index on Linux requirements-engine.txt; run-install.sh
System packages build-essential and ffmpeg (installed by the script with sudo apt) run-install.sh
Web UI Gradio on 127.0.0.1, port 6969 by default app.py
Batch size Pick a value that fits the GPU’s VRAM; reduce it if training runs out of memory Applio docs, Train a voice model

VRAM need depends on model, precision and workflow; see How much VRAM do I need to run an LLM? for the general method. For Applio, batch size is the setting the docs tie to the GPU’s VRAM; the VRAM of each card is in the Performance table on /pricing (CloudGPU’s own listing).

Step 1: Prepare the dataset on your computer

According to the Applio docs, use clean recordings of the intended speaker with varied phrases, pitches and delivery, and keep the originals while you work on copies. Put the files in one folder per voice, for example MyVoice/. For a multi-speaker project, the docs keep numeric subfolders (MyVoice/0/, MyVoice/1/).

Step 2: Deploy a Raw GPU and connect

On /deploy, pick an NVIDIA GPU and the Raw GPU option (JupyterLab + CUDA pre-installed, root SSH on a dedicated container). Connect over SSH with the host, port and user shown for your instance, or open a terminal in JupyterLab.

Step 3: Check the GPU and tools

nvidia-smi          # GPU name, driver version and the "CUDA Version" the driver supports
nvcc --version      # CUDA toolkit compiler, if installed (the Applio install script does not call it)
which git tmux rsync ffmpeg sudo
nproc               # CPU cores, used by --cpu-cores in Step 6

Applio’s Linux install pulls PyTorch from the cu128 wheel index, so compare the “CUDA Version” in the nvidia-smi header with 12.8. If tmux, rsync or git is missing, install it with apt (you are root on the container).

Step 4: Install Applio

The Applio docs give these commands for a source install on Linux. Run them inside tmux so the install keeps going if SSH disconnects:

tmux new -s applio
cd ~
git clone https://github.com/IAHispano/Applio.git
cd Applio
bash run-install.sh

run-install.sh installs build-essential and ffmpeg with sudo apt, installs uv if it is missing, creates .venv with Python 3.12 and installs the requirements, with PyTorch from the cu128 wheel index. If run-install.sh reports that sudo is not found, run apt install -y sudo first, then rerun it:

apt update && apt install -y sudo
bash run-install.sh

Check that PyTorch sees the GPU:

cd ~/Applio && source .venv/bin/activate
python -c "import torch; print(torch.__version__, torch.cuda.is_available(), torch.cuda.get_device_name(0))"

Step 5: Upload the dataset

From your computer, copy the dataset folder into Applio’s dataset folder on the instance:

rsync -avP -e "ssh -p <ssh-port>" ./MyVoice/ <ssh-user>@<ssh-host>:Applio/assets/datasets/MyVoice/

Step 6: Train the model

Option A: in the Applio web UI over an SSH tunnel

run-applio.sh starts python app.py --open, which also tries to open a browser. On a server, start the app directly; by default it listens on 127.0.0.1 port 6969 and downloads its prerequisite models on launch:

cd ~/Applio && source .venv/bin/activate
python app.py --port 6969 --server-name 127.0.0.1

On your computer, open a tunnel and browse to http://localhost:6969:

ssh -N -L 6969:127.0.0.1:6969 -p <ssh-port> <ssh-user>@<ssh-host>

If the app prints a different port (the docs say to read the printed address if the requested port is in use), tunnel that port instead. The Applio CLI docs note that --share requests a public Gradio link that exposes your session, so the SSH tunnel keeps the UI private. See How to use SSH port forwarding on a cloud GPU for details.

In the Training tab, enter a model name, pick the dataset path assets/datasets/MyVoice, and follow the docs’ order: preprocess, extract features, train, then generate the index.

Option B: from the command line in tmux

The Applio CLI docs give this 40 kHz example; replace the model name, paths and settings for your experiment, and set --cpu-cores to a value up to the nproc result:

cd ~/Applio && source .venv/bin/activate
python core.py prerequisites
python core.py preprocess --model-name MyVoice --dataset-path "assets/datasets/MyVoice" --sample-rate 40000 --cpu-cores 4
python core.py extract --model-name MyVoice --sample-rate 40000 --cpu-cores 4 --gpu 0 --f0-method rmvpe --embedder-model contentvec
python core.py train --model-name MyVoice --sample-rate 40000 --gpu 0 --batch-size 4 --save-every-epoch 10 --total-epoch 200
python core.py index --model-name MyVoice --index-algorithm Auto

According to the docs, pitch and embedder settings belong to extract, not train, and --cleanup clears a previous attempt, so do not use it when you resume. Run python core.py train --help for the options in your checkout. Detach from tmux with Ctrl-b then d, and reattach with tmux attach -t applio.

Step 7: Watch training and test the model

Applio’s run-tensorboard.sh runs python core.py tensorboard. Start it in a second tmux window and reach it with an SSH tunnel to the port it prints. The Applio docs say a lower total loss does not by itself mean a better voice; convert the same held-out clips with saved checkpoints and listen. A single-file test from the CLI docs:

python core.py infer --input-path "test.wav" --output-path "converted.wav" --pth-path "logs/MyVoice/MyVoice.pth" --index-path "logs/MyVoice/MyVoice.index"

Check your own setup

These are checks you can run yourself; this page does not assume the result.

  • PyTorch sees the GPU: the Step 4 check prints True and your GPU name.
  • Training uses the GPU: while train runs, nvidia-smi in a second SSH session lists a python process on the GPU. See How to check GPU utilization on a cloud GPU.
  • Files are written: ls ~/Applio/logs/MyVoice shows checkpoints and, after the index step, an .index file.

If training runs out of GPU memory

According to the Applio training docs, reduce the batch size, turn off dataset caching in GPU memory, or try checkpointing where supported. The CLI lists --batch-size, --cache-data-in-gpu and --checkpointing as training options. Otherwise, deploy a card with more VRAM from /pricing.

Before you destroy the instance

According to /terms, data on the instance is permanently deleted when you destroy it. The Applio cloud docs say to back up the full experiment folder (checkpoints, configuration, feature files), not only the inference export, if you want to resume later. Copy it to your computer first:

rsync -avP -e "ssh -p <ssh-port>" <ssh-user>@<ssh-host>:Applio/logs/MyVoice/ ./MyVoice-experiment/

The docs also note that a closed browser does not mean the remote process has stopped, so stop training in tmux before you destroy. GPU time is billed per minute, rounded up, with a 1-minute minimum, and billing stops when you destroy the instance; see /terms.

FAQ

Can I train an Applio RVC model on a rented GPU without a desktop?

Yes. The Applio docs describe a source install for Linux: git clone https://github.com/IAHispano/Applio.git, then bash run-install.sh. You can then train in the web UI through an SSH tunnel to port 6969, or run python core.py preprocess, extract, train and index from the command line.

How do I open the Applio web UI on a cloud GPU?

Start it with python app.py --port 6969 --server-name 127.0.0.1, then run ssh -N -L 6969:127.0.0.1:6969 -p @ on your computer and open http://localhost:6969. The Applio docs note that --share requests a public link that exposes your session.

What batch size should I use for Applio training?

The Applio training docs say to choose a batch size that fits the GPU’s VRAM and to reduce it if training runs out of memory. The CLI example uses --batch-size 4. For memory errors the docs also suggest turning off dataset caching in GPU memory or trying checkpointing.

Which files do I need to keep after Applio training?

Export the inference .pth and its matching .index to use the voice. To resume training later, the Applio docs say to keep the G_.pth and D_.pth checkpoints and back up the full experiment folder, because the small inference export does not contain the full training state.

How is the GPU billed while Applio trains?

GPU time is billed per minute, rounded up, with a 1-minute minimum, and billing stops when you destroy the instance. Copy your experiment folder off first, because data on the instance is deleted on destroy. See https://cloudgpu.app/terms for the full billing terms.

Sources