YOLO training GPU cloud guide: computer vision projects in Asia

Defect detection on a production line, shelf monitoring in convenience stores, helmet checks on construction sites, licence-plate reading at car parks: computer vision projects across Southeast Asia often start with a YOLO model and a pile of labelled images. Training on a laptop is slow, and buying a GPU for a three-week project rarely makes sense. This YOLO training GPU cloud guide follows one realistic project from dataset to exported model on a rented Cloudj GPU, and shows why the size of your dataset, not your users, decides where to rent.

The example project

A system integrator in Ho Chi Minh City is building shelf-gap detection for a retail chain. They have:

• About 60,000 labelled images from store cameras, around 40 GB as JPEG.
• A target device in each store: a small edge box that will run the model.
• A deadline of three weeks, with several training rounds as labels improve.

Nobody waits on the GPU in real time; training is a batch job. So the only location question is: how fast can the 40 GB get to the GPU, and the trained weights get back?

Step 1: let dataset size choose the region

The GPU cloud Asia guide explains the Asian codes, and moving models and data between GPU regions covers transfer strategies for large datasets. If the dataset is small, the logic in LoRA training on a US GPU applies: location hardly matters for batch training.

Stock changes during the day. If SG, HK lists nothing suitable, add JP, try later or loosen filters.

Step 2: pick a mid-range card

YOLO detection models are small compared with language models. A mid-range consumer card is usually enough:

• RTX 4070 Ti Super, 16 GB: fine for nano to medium models at standard image sizes.
• RTX 3090, 24 GB: room for larger models, bigger batches or higher resolutions.
• RTX 4090, 24 GB: faster training rounds when you iterate often.

All three are available at the starting account level. RTX 3090 cloud in Asia focuses on that card. Live "from" prices are on GPU cloud.

Do not overlook the CPU and disk in the result list: data loading and augmentation run on the CPU, so a machine with very few vCPUs can leave the GPU idle. Choose a disk large enough for the dataset, its cache and several training runs; disk size cannot be changed after deploy.

Step 3: deploy and upload once

Open the RTX 3090 deploy page, enter SG, HK, check reliability, max duration and download speed, choose the PyTorch + JupyterLab or Ubuntu + CUDA template, select your SSH key and deploy.

Upload the dataset with rsync, which resumes if the connection drops:

rsync -avP -e "ssh -p PORT" ./dataset/ root@HOST:/workspace/dataset/

For tens of thousands of small files, packing them first is often faster:

tar -cf dataset.tar dataset/
rsync -avP -e "ssh -p PORT" dataset.tar root@HOST:/workspace/

Step 4: train

Connect and install the training library:

ssh -p PORT root@HOST
nvidia-smi
pip install ultralytics
tmux new -s yolo
cd /workspace
yolo detect train data=/workspace/dataset/data.yaml model=yolo11s.pt epochs=100 imgsz=640 batch=-1

If you uploaded a tar file, unpack it first with tar -xf /workspace/dataset.tar -C /workspace. batch=-1 lets the trainer pick a batch size that fits the GPU memory. Running inside tmux keeps training alive if your SSH session drops. The Ultralytics documentation covers every training argument, from augmentation to early stopping.

Watch progress from another session:

watch -n 5 nvidia-smi
tail -f runs/detect/train/results.csv

Step 5: export and bring the model home

When training ends, the best weights are in runs/detect/train/weights/best.pt. Export a portable format for your edge devices:

yolo export model=runs/detect/train/weights/best.pt format=onnx

Then pull the results:

rsync -avP -e "ssh -p PORT" root@HOST:/workspace/runs/ ./runs/

If your edge device uses TensorRT, build the TensorRT engine on the device itself or on matching hardware, since engines are tied to the GPU and software version they were built for.

Between training rounds

Labels improve, and you will train again. Two options:

• Destroy and redeploy for each round. You pay nothing between rounds, but you upload the dataset again. Good when rounds are days apart.
• Stop the instance. The disk and dataset stay, charged at storage price, but the GPU is released and restarting waits until it is free. Good when the next round is soon and the dataset is large.

Either way, keep the best weights and training config off the machine. The instance and disk are removed at the machine's "available until" date, and hosts have no hardware SLA.

Licences and data

Check the licence of the training library and pretrained weights you use before shipping a commercial product; some popular YOLO implementations use copyleft licences with separate commercial terms. Store camera footage carefully, as it may show people, and check your own legal obligations.

FAQ

Is a cheap mid-range GPU enough for YOLO?

Usually yes. A 16 GB or 24 GB RTX card handles most detection projects at standard image sizes.

Should I rent the GPU near my store cameras?

Only to shorten the dataset upload. Training does not need to be near users.

Can I run YOLO inference for live cameras on the cloud GPU?

You can, but most retail and factory projects run inference on edge devices and use the cloud only for training.

Does Cloudj preinstall Ultralytics?

No. Install it with pip over SSH, or bring a public Docker image.

Next step

Open the RTX 3090 deploy page, search SG, HK, and run a short training round on a sample of your dataset before the full upload.