§6

Fine-tuning and training platforms

Fine-tuning is how you get a smaller, cheaper, or more obedient model to beat a large general model on one narrow task — format adherence, domain jargon, classification, tool-call shape, latency and cost per request. The landscape splits three ways: managed API services that take a JSONL file and hand back a served model, open-source trainer frameworks you run on GPUs you rent, and the raw GPU clouds underneath them.

Data checked 2026-09-06

As of September 2026 the category's most famous entry has changed shape dramatically: OpenAI is winding down its own fine-tuning platform and has closed it to new users, pushing that workload to Azure AI Foundry, while Predibase has been absorbed into Rubrik and Hugging Face's AutoTrain is explicitly unmaintained. The techniques themselves — LoRA, QLoRA, DPO, GRPO, and reinforcement fine-tuning — have consolidated enough that most platforms now expose the same menu, so the choice is increasingly about serving economics and operational control rather than algorithms.

A How to choose

Start with the question of who serves the model, because that dominates total cost far more than training does — training a LoRA is usually tens of dollars, while a dedicated endpoint is $2–9/hour whether or not you send it traffic. If your volume is bursty or low, pick a platform with multi-LoRA serverless serving (Fireworks serves fine-tuned models at base-model token rates; Together and Nebius bill dedicated hosting by the hour), because an idle H100 will out-cost your entire training budget in a week. Second axis: do you need a closed frontier model or will an open-weight model do?

If you specifically need GPT-class weights tuned, Azure AI Foundry is now the only real path — OpenAI's direct platform is closed to new users and existing users only have "the coming months" to create jobs — and Vertex AI is the equivalent for Gemini. Third axis: control versus convenience. Managed token-priced services are the right default and you should not run your own trainer until you have a concrete reason (a custom loss, an unsupported architecture, data that cannot leave your VPC, or a training bill large enough that GPU-hour pricing beats per-token pricing); when you do, Axolotl or TRL on Modal or RunPod is the standard stack, with Unsloth when you are squeezing a single consumer GPU.

Fourth axis: method. Do not reach for DPO, GRPO, or RFT first — SFT on a few hundred well-curated examples solves the large majority of real problems, and preference or RL methods only pay off once SFT has plateaued and you have a reliable grader or preference signal. The commonly overrated choice is reinforcement fine-tuning: it is priced by the hour (OpenAI charged $100/hour for o4-mini RFT), it needs a programmatic grader you probably do not have, and teams routinely spend weeks on it to lose to a better-written prompt plus retrieval.

The commonly underrated move is doing nothing: benchmark prompt engineering, few-shot examples, and a smaller base model before you fine-tune anything, because a fine-tune freezes you to a base model that will be superseded in about six months.

B At a glance

Name	Methods	Base models	Price unit	Serving	Data needed	Pricing
OpenAI Fine-tuning	SFT, DPO, vision SFT, RFT (o4-mini)	gpt-4.1 / mini / nano, gpt-4o, gpt-4o-mini, o4-mini	Per 1M training tokens; RFT per hour	OpenAI API only, no weight export	Minimum 10 examples; 50–100 recommended	Training: gpt-4.1 $25.00/1M tokens, gpt-4.1-mini $5.00/1M, gpt-4.1-nano $1.50/1M, gpt-4o $25.00/1M, gpt-4o-mini $3.00/1M. RFT on o4-mini $100.00/hour. Fine-tuned inference: gpt-4.1 $3.00 in / $12.00 out per 1M; o4-mini $4.00 / $16.00.
Azure OpenAI Fine-tuning (AI Foundry)	SFT, DPO, RFT	gpt-4.1/mini/nano, gpt-4o, o4-mini, gpt-5 (RFT, gated), Llama-3.3-70B, Qwen-32B, gpt-oss-20b	Per training token + hourly deployment hosting	Azure-managed endpoints (Standard/Global/Developer tiers)	JSONL chat format; tens to hundreds of examples for SFT	Rates published on the Azure OpenAI pricing page and vary by tier (Standard / Global / Developer); exact per-token figures not captured here — treat as unknown. Structurally: per-token training charge plus an hourly hosting fee for each deployed fine-tuned model, billed whether or not it serves traffic.
Together Fine-tuning	LoRA (default), full fine-tuning, SFT, DPO preference tuning	DeepSeek V4/V3.1, Qwen 0.8B–397B, Llama 4, Gemma 4, Nemotron 3, Kimi K2, GLM, gpt-oss	Per 1M training tokens ($4 job minimum)	Dedicated endpoints $3.99–$8.99/hr; weights downloadable	JSONL; hundreds to thousands of examples typical	Fine-tuning $0.48–$8.00 per 1M tokens for standard models, $3.00–$100 per 1M for specialized/large models; $4.00 minimum charge per job. Dedicated inference $3.99/hour (H100, promotional) to $8.99/hour (B200). GPU clusters $1.99–$5.99/hour preemptible H100, $8.19/hour on-demand B200. Storage $0.16/GiB-month.
Fireworks AI Fine-tuning	LoRA, full-parameter fine-tuning, DPO, RFT	Open-weight catalogue (Llama, Qwen, DeepSeek, gpt-oss and similar), banded by parameter count	Per 1M training tokens, banded by model size; GPU-hour for dedicated training	Serverless multi-LoRA at base-model token rates; dedicated optional	JSONL; hundreds of examples for LoRA SFT	LoRA training: $0.50/1M tokens (≤16B), $3.00/1M (16.1–80B), $6.00/1M (80–300B), $10.00/1M (>300B). Full fine-tuning: $1.00 / $6.00 / $12.00 / $40.00 per 1M at the same size bands. DPO costs 2x the SFT rate. Serving fine-tuned models: same per-token price as the base model.
Google Vertex AI Tuning	Supervised fine-tuning, preference tuning, reinforcement learning fine-tuning, distillation; LoRA/QLoRA for open models	Gemini family; open models via Model Garden	Per training token + endpoint inference (unknown exact rates)	Vertex endpoints, Provisioned Throughput or PayGo, batch inference	JSONL; text, document, image, audio, video and function-calling formats	unknown — the Vertex generative AI pricing page did not render usable per-token tuning rates during research. Billing is structurally per training token plus standard endpoint inference (PayGo or Provisioned Throughput). Verify on the official pricing page before budgeting.
Nebius (AI Cloud + Token Factory)	Token Factory: supervised fine-tuning (LoRA or full weights), speculator training; RFT gated. AI Cloud: any framework you run	Open-weight catalogue in Token Factory; anything on raw GPUs	Per GPU-hour ($2.15–$7.15); Token Factory training rates unknown	Token Factory endpoints for custom models; self-managed on AI Cloud	JSONL for Token Factory; unconstrained on raw GPUs	GPU-hour: H100 $2.15 preemptible / $3.85 on-demand; H200 $2.45 / $4.50; B200 $3.95 / $7.15; L40S (AMD) from $0.74 / $1.55, (Intel) from $0.90 / $1.82. Up to 35% off for large reserved clusters. Storage: shared filesystem $0.08/GiB-month, WEKA $0.10/GiB-month, object storage $0.0147–$0.11/GiB-month. Managed Kubernetes free. Token Factory post-training rates: unknown.
Predibase	Formerly LoRA/QLoRA SFT and GRPO reinforcement fine-tuning; current availability unknown	Formerly open-weight small models (Llama, Qwen, Mistral, Phi)	unknown	Formerly serverless multi-LoRA via LoRAX	unknown	unknown — the standalone Predibase pricing page is gone and Rubrik does not publish self-serve fine-tuning rates. Formerly a per-GPU-hour training charge plus per-token serverless LoRA inference.
Unsloth	LoRA, QLoRA, full fine-tuning, DPO, GRPO, RL	500+ including Qwen3.8, GLM-5.3, DeepSeek-V4, Gemma 4, Llama 4, Mistral, Phi-4, plus vision/TTS/embedding/diffusion	Free; you pay GPU-hour to whoever hosts it	None built in — export GGUF/adapters to vLLM, Ollama or llama.cpp	Any HF dataset format; hundreds of examples upward	Free and open source; you pay only for the GPU you run it on (e.g. $0.49–$0.74/hr for a 4090 or L4 on RunPod, or $0 on a free Colab T4). Paid tiers exist but rates were not retrievable during research.
Axolotl	Full FT, LoRA, QLoRA, GPTQ, QAT (int8/int4/FP8/NVFP4/MXFP4), FP8 mixed-precision, DPO, IPO, KTO, ORPO, GRPO, GDPO, RM/PRM	GPT-OSS, Llama, Mistral, Mixtral, Qwen, Gemma and most HF Hub architectures; VLMs incl. LLaVA and Qwen2-VL	Free; GPU-hour from your provider	None — export weights/adapters to vLLM, TGI or LoRAX	Many built-in dataset formats; thousands of examples for full FT	Free, Apache 2.0. Cost is entirely the GPU you rent — commonly $1.59–$3.49/hr for an A100 or H100 on RunPod, or $2.15–$3.85/hr on Nebius.
TRL (Transformer Reinforcement Learning)	SFT, DPO, KTO, BCO, CPO, ORPO, GRPO, RLOO, OnlineDPO, PPO, NashMD, XPO, RewardTrainer, PRM, Distillation, GKD, MiniLLM	Any transformers-compatible causal LM or VLM	Free; GPU-hour from your provider	None — vLLM integration is for training-time generation, not deployment	Method-specific; prompt/completion for SFT, chosen/rejected pairs for DPO, verifiable rewards for GRPO	Free, Apache 2.0. Cost is your GPU time only.
LLaMA-Factory	LoRA, QLoRA, OFT, QOFT, full tuning, freeze tuning, continuous pre-training, DPO, KTO, ORPO, SimPO, PPO	100+ incl. Llama, Qwen3, DeepSeek-R1, Gemma 3, Mistral, GLM, Phi, LLaVA, Qwen2-VL	Free; GPU-hour from your provider	Built-in inference for testing; export to vLLM for production	Alpaca or ShareGPT JSON formats; hundreds of examples upward	Free, Apache 2.0. GPU cost only.
Hugging Face AutoTrain	SFT, LoRA, DPO, ORPO, reward modelling; also CV and tabular tasks	Hugging Face Hub models as of its last release	Free package + HF Space GPU hourly	Push to Hub, then serve separately	CSV or JSONL	The package is free; running it on a Hugging Face Space required paying for attached GPU hardware. No current pricing is meaningful given the project is unmaintained.
LoRAX	Serving only — consumes LoRA adapters trained elsewhere	Common open-weight architectures supported by its backend	Free; GPU-hour for the host machine	This is the serving layer — OpenAI-compatible, multi-adapter, streaming	None — takes trained adapters, not datasets	Free, Apache 2.0. Cost is the single GPU you run it on — from $0.49/hr (L40S-class on RunPod Community) to $3.49/hr (H100 SXM).
Modal	Any — you run Axolotl, TRL, Unsloth or your own script	Anything you can pull into a container	Per GPU-second ($0.000164–$0.001972/s) plus CPU and memory	Serverless inference endpoints on the same platform, scale-to-zero	Unconstrained — you own the pipeline	Starter: free, $30/month credits, 3 seats, 100 containers, 10 GPU concurrency. Team: $250/month base with $100/month credits, unlimited seats, 5,000 containers, 50 GPU concurrency. GPUs $0.000164/sec (T4) to $0.001972/sec (B300). CPU $0.0000131/core-sec, memory $0.00000222/GiB-sec, volume storage $0.09/GiB-month.
RunPod	Any — bring Axolotl, Unsloth, TRL or LLaMA-Factory templates	Anything you can download	Per GPU-hour, billed per second ($0.49–$3.49/hr Secure Cloud)	Separate serverless inference product, $0.58–$9.98/hr	Unconstrained — you own the pipeline	Secure Cloud per hour: H100 SXM $3.49, H100 PCIe $2.89, A100 SXM $1.59, L40S $1.09, RTX 6000 Ada $0.84, RTX 4090 $0.74, RTX 3090 $0.50, A40 $0.49, L4 $0.49. Community Cloud is 15–30% cheaper. Serverless $0.58–$9.98/hr. Network storage from $0.05/GB/month standard (above 1TB), $0.14/GB/month high-performance.
LoRA (Low-Rank Adaptation)	Parameter-efficient supervised fine-tuning; composes with DPO and GRPO	Any open-weight transformer; also the default on Together, Fireworks and Nebius	Cheapest managed tier ($0.50–$10/1M tokens) or GPU-hour	Adapters hot-swappable — enables multi-LoRA serving on one GPU	Hundreds to a few thousand examples	Free as a technique. In practice: $0.50–$10 per 1M training tokens on managed platforms, or a few dollars of GPU time self-hosted.
QLoRA	4-bit NF4 quantized base + LoRA adapters, with paged optimizers	Any open-weight transformer; supported in Unsloth, Axolotl, LLaMA-Factory, TRL/PEFT, Vertex	Single GPU-hour, typically $0.49–$0.74/hr consumer-class	Usually serve adapters against a 16-bit base; 4-bit serving optional	Hundreds to a few thousand examples	Free as a technique. Real cost is the single GPU: roughly $0.49–$0.74/hr on RunPod, or $0 on a free Colab T4 for small models.
DPO (Direct Preference Optimization)	Offline preference optimization; variants IPO, KTO, ORPO, CPO, SimPO	Supported on gpt-4.1 family (Azure), Together, Fireworks, Vertex, and any open model via TRL	~2x the SFT per-token rate	Produces a normal model or adapter — serves like any fine-tune	Prompt + chosen + rejected triples; typically 1,000+ pairs	Free as a technique; roughly 2x SFT cost on managed platforms (Fireworks charges exactly 2x the SFT rate, so $1.00/1M tokens for a ≤16B LoRA).
GRPO (Group Relative Policy Optimization)	Online RL with group-normalised advantages; relatives RLOO, GDPO, PPO	Any open-weight model via TRL, Axolotl or Unsloth; Vertex offers a managed RL path	GPU-hour (generation-heavy, multiples of SFT cost)	Produces a normal model or adapter	Prompts plus a programmatic reward function; no labelled outputs required	Free as a technique. Cost is dominated by generation: expect several times an equivalent SFT run in GPU-hours, so $2.15–$3.85/hr Nebius or $3.49/hr RunPod H100 time for hours to days.
RFT (Reinforcement Fine-Tuning)	Managed reinforcement learning against scoring or model graders	o4-mini and gpt-5 (Azure, gpt-5 gated); Gemini via Vertex RL tuning; o4-mini on OpenAI while it lasts	Per training hour ($100/hr on OpenAI) plus grading tokens	Provider-hosted endpoints only; no weight export	Prompts plus a grader; no labelled outputs, but graders take real engineering	OpenAI (winding down): $100.00/hour of training on o4-mini, plus "tokens used for model grading in reinforcement fine-tuning are billed at that model's per-token rate". Fine-tuned o4-mini inference $4.00 in / $16.00 out per 1M. Azure RFT rates not captured — verify on the Azure OpenAI pricing page.

C Entries

OpenAI Fine-tuning

The managed service that popularised JSONL-in, served-model-out fine-tuning, supporting SFT and DPO on gpt-4.1/mini/nano, vision SFT on gpt-4o, and reinforcement fine-tuning on o4-mini. OpenAI's own docs now state it is winding down and "no longer accessible to new users", with existing users able to create training jobs "for the coming months" and fine-tuned models remaining servable until their base models are deprecated. Published training rates were $25/1M tokens for gpt-4.1, $5 for 4.1-mini, $1.50 for 4.1-nano, and $100/hour for o4-mini RFT. New workloads that need OpenAI weights should go to Azure AI Foundry instead.

Methods	SFT, DPO, vision SFT, RFT (o4-mini)
Base models	gpt-4.1 / mini / nano, gpt-4o, gpt-4o-mini, o4-mini
Price unit	Per 1M training tokens; RFT per hour
Serving	OpenAI API only, no weight export
Data needed	Minimum 10 examples; 50–100 recommended

Watch out: Discontinued for new users — do not design around it. Even existing users face an unstated deadline, and the whole platform was always locked to OpenAI base models with no weight export, so there is no way to take a tuned model elsewhere. Migration to Azure means re-running jobs and re-validating quality.

Training: gpt-4.1 $25.00/1M tokens, gpt-4.1-mini $5.00/1M, gpt-4.1-nano $1.50/1M, gpt-4o $25.00/1M, gpt-4o-mini $3.00/1M. RFT on o4-mini $100.00/hour. Fine-tuned inference: gpt-4.1 $3.00 in / $12.00 out per 1M; o4-mini $4.00 / $16.00. · deprecated

Azure OpenAI Fine-tuning (AI Foundry)

Azure AI Foundry runs GA fine-tuning for gpt-4.1/mini/nano and gpt-4o (SFT and DPO), o4-mini and gpt-5 (RFT, with gpt-5 RFT invitation-gated), plus SFT on open models like Llama-3.3-70B, Qwen-32B, Ministral-3B and gpt-oss-20b. Three training tiers trade price against guarantees: Standard trains in your region with data residency, Global uses out-of-region capacity for less, and Developer uses idle capacity with no SLA and preemptible jobs. With OpenAI's first-party platform closing, this is now the practical home for GPT-weight fine-tuning.

Methods	SFT, DPO, RFT
Base models	gpt-4.1/mini/nano, gpt-4o, o4-mini, gpt-5 (RFT, gated), Llama-3.3-70B, Qwen-32B, gpt-oss-20b
Price unit	Per training token + hourly deployment hosting
Serving	Azure-managed endpoints (Standard/Global/Developer tiers)
Data needed	JSONL chat format; tens to hundreds of examples for SFT

Watch out: The hourly hosting charge per deployed model makes low-traffic fine-tunes expensive, and deployments idle for 15+ days are auto-deleted. Model availability is restricted to a handful of regions (mostly North Central US and Sweden Central), gpt-5 RFT is invite-only, and you need the Foundry Owner role to deploy — a real friction point in locked-down enterprise tenants. Azure's resource and quota model is substantially more setup than a single API key.

Rates published on the Azure OpenAI pricing page and vary by tier (Standard / Global / Developer); exact per-token figures not captured here — treat as unknown. Structurally: per-token training charge plus an hourly hosting fee for each deployed fine-tuned model, billed whether or not it serves traffic.

Together Fine-tuning

Together runs managed LoRA (the default) and full fine-tuning, with supervised and DPO-based preference training, across a wide open-weight catalogue: DeepSeek V4 Flash and V3.1, Qwen from 0.8B to 397B, Llama 4 Scout and Maverick, Gemma 4, Nemotron 3, Kimi K2, GLM and gpt-oss, at context lengths up to 131K. It also supports vision, function-calling and reasoning-model fine-tuning. Unlike the closed platforms, you can download your trained weights and serve them elsewhere, and Together will also rent you the raw GPUs ($1.99–$8.19/hour) if you outgrow the managed path.

Methods	LoRA (default), full fine-tuning, SFT, DPO preference tuning
Base models	DeepSeek V4/V3.1, Qwen 0.8B–397B, Llama 4, Gemma 4, Nemotron 3, Kimi K2, GLM, gpt-oss
Price unit	Per 1M training tokens ($4 job minimum)
Serving	Dedicated endpoints $3.99–$8.99/hr; weights downloadable
Data needed	JSONL; hundreds to thousands of examples typical

Watch out: The $0.48–$100/1M token spread is wide and the expensive end arrives fast on large MoE models, so estimate before you launch a job. Serving a fine-tune usually means a dedicated endpoint at $3.99–$8.99/hour rather than per-token serverless, which is poor economics below roughly continuous load. No GPT or Gemini weights, and no reinforcement-learning method beyond DPO-style preference tuning.

Fine-tuning $0.48–$8.00 per 1M tokens for standard models, $3.00–$100 per 1M for specialized/large models; $4.00 minimum charge per job. Dedicated inference $3.99/hour (H100, promotional) to $8.99/hour (B200). GPU clusters $1.99–$5.99/hour preemptible H100, $8.19/hour on-demand B200. Storage $0.16/GiB-month.

Fireworks AI Fine-tuning

Fireworks prices LoRA fine-tuning by model size — $0.50/1M tokens up to 16B, $3.00 for 16–80B, $6.00 for 80–300B, $10.00 above 300B — with full-parameter training at roughly double and DPO at double the corresponding SFT rate. Its distinguishing property is serving: fine-tuned models cost the same per token as the base model, with no separate adapter deployment fee, which removes the idle-GPU problem that makes dedicated endpoints expensive elsewhere. A serverless training API bills prefill, caching, sampling and training separately, and a dedicated training API bills per GPU hour.

Methods	LoRA, full-parameter fine-tuning, DPO, RFT
Base models	Open-weight catalogue (Llama, Qwen, DeepSeek, gpt-oss and similar), banded by parameter count
Price unit	Per 1M training tokens, banded by model size; GPU-hour for dedicated training
Serving	Serverless multi-LoRA at base-model token rates; dedicated optional
Data needed	JSONL; hundreds of examples for LoRA SFT

Watch out: Serverless multi-LoRA serving means cold starts and shared-tenancy latency variance; predictable low-latency production still pushes you to a dedicated deployment at GPU-hour rates. The catalogue of fine-tunable base models is narrower than Together's, and the layered pricing (serverless training API vs dedicated training API vs per-token training) is genuinely hard to forecast until you have run a job.

LoRA training: $0.50/1M tokens (≤16B), $3.00/1M (16.1–80B), $6.00/1M (80–300B), $10.00/1M (>300B). Full fine-tuning: $1.00 / $6.00 / $12.00 / $40.00 per 1M at the same size bands. DPO costs 2x the SFT rate. Serving fine-tuned models: same per-token price as the base model.

Google Vertex AI Tuning

Vertex AI offers supervised fine-tuning, preference tuning, reinforcement learning fine-tuning (with configurable reward functions) and distillation for Gemini models, and is unusual in covering document, image, audio, video and function-calling tuning rather than text alone. Tuned models deploy to standard Vertex endpoints with a choice of pay-as-you-go or Provisioned Throughput, and batch inference is available. For open models it documents LoRA and QLoRA paths alongside distillation.

Methods	Supervised fine-tuning, preference tuning, reinforcement learning fine-tuning, distillation; LoRA/QLoRA for open models
Base models	Gemini family; open models via Model Garden
Price unit	Per training token + endpoint inference (unknown exact rates)
Serving	Vertex endpoints, Provisioned Throughput or PayGo, batch inference
Data needed	JSONL; text, document, image, audio, video and function-calling formats

Watch out: Pricing is difficult to pin down and Provisioned Throughput commitments are a meaningful spend decision rather than a per-token trickle. The reinforcement-learning fine-tuning path requires you to author reward functions, which is a real engineering project. Like all closed-weight tuning you cannot export the model, and Vertex's IAM, region and quota surface is heavier than a single-API-key service.

unknown — the Vertex generative AI pricing page did not render usable per-token tuning rates during research. Billing is structurally per training token plus standard endpoint inference (PayGo or Provisioned Throughput). Verify on the official pricing page before budgeting.

Nebius (AI Cloud + Token Factory)

Nebius sells two things relevant here: raw GPU capacity at some of the lowest published European rates (H100 $2.15/hr preemptible, $3.85 on-demand; H200 $2.45/$4.50; B200 $3.95/$7.15; L40S from $0.74/hr) with up to 35% off for reserved clusters, and Token Factory, a managed post-training service doing supervised fine-tuning producing either LoRA adapters or full model weights, plus custom speculator training for faster inference. Reinforcement fine-tuning is flagged as coming as a limited professional service requiring access request.

Methods	Token Factory: supervised fine-tuning (LoRA or full weights), speculator training; RFT gated. AI Cloud: any framework you run
Base models	Open-weight catalogue in Token Factory; anything on raw GPUs
Price unit	Per GPU-hour ($2.15–$7.15); Token Factory training rates unknown
Serving	Token Factory endpoints for custom models; self-managed on AI Cloud
Data needed	JSONL for Token Factory; unconstrained on raw GPUs

Watch out: Token Factory's post-training pricing is not clearly published and its method menu is thinner than competitors — supervised fine-tuning only, with DPO and distillation not documented and RFT gated behind a sales conversation. The raw cloud is a GPU cloud, not a training product: you bring Axolotl or TRL and operate the cluster yourself. Preemptible instances at $2.15/hr will interrupt long runs unless you checkpoint aggressively.

GPU-hour: H100 $2.15 preemptible / $3.85 on-demand; H200 $2.45 / $4.50; B200 $3.95 / $7.15; L40S (AMD) from $0.74 / $1.55, (Intel) from $0.90 / $1.82. Up to 35% off for large reserved clusters. Storage: shared filesystem $0.08/GiB-month, WEKA $0.10/GiB-month, object storage $0.0147–$0.11/GiB-month. Managed Kubernetes free. Token Factory post-training rates: unknown.

Predibase

Predibase was the best-known specialist in small-model fine-tuning, notable for pioneering serverless multi-LoRA serving via its open-source LoRAX server and for shipping end-to-end GRPO reinforcement fine-tuning ahead of the general market. Following acquisition by Rubrik, predibase.com now redirects to the Rubrik Agent Cloud product page and docs.predibase.com redirects to rubrik.com, indicating the standalone self-serve platform is no longer being sold under its own name. The LoRAX inference server remains on GitHub under Apache 2.0 and is the durable piece of the legacy.

Methods	Formerly LoRA/QLoRA SFT and GRPO reinforcement fine-tuning; current availability unknown
Base models	Formerly open-weight small models (Llama, Qwen, Mistral, Phi)
Price unit	unknown
Serving	Formerly serverless multi-LoRA via LoRAX
Data needed	unknown

Watch out: Treat as discontinued as a self-serve product: you cannot sign up for the platform as it existed, and any evaluation should assume an enterprise sales motion through Rubrik with no published pricing. Existing customers should confirm migration terms directly. Confidence on Rubrik's forward roadmap for fine-tuning specifically is low — the redirects establish the acquisition outcome but not what survives inside Agent Cloud.

unknown — the standalone Predibase pricing page is gone and Rubrik does not publish self-serve fine-tuning rates. Formerly a per-GPU-hour training charge plus per-token serverless LoRA inference. · discontinued

Unsloth

Unsloth rewrites the hot paths of transformer training with custom Triton kernels, claiming 2x faster training with 70% less VRAM and no accuracy loss, which in practice is what lets people QLoRA a mid-size model on one consumer GPU or a free Colab T4. It supports LoRA, QLoRA, full fine-tuning, DPO, GRPO and RL across 500+ models including Qwen3.8, GLM-5.3, DeepSeek-V4, Gemma 4, Llama 4 and Phi-4, plus vision, TTS, embedding and diffusion models, and now ships a desktop app and an `unsloth start` CLI alongside its notebooks. It runs on macOS, Linux and Windows across NVIDIA, AMD, Intel and CPU.

Methods	LoRA, QLoRA, full fine-tuning, DPO, GRPO, RL
Base models	500+ including Qwen3.8, GLM-5.3, DeepSeek-V4, Gemma 4, Llama 4, Mistral, Phi-4, plus vision/TTS/embedding/diffusion
Price unit	Free; you pay GPU-hour to whoever hosts it
Serving	None built in — export GGUF/adapters to vLLM, Ollama or llama.cpp
Data needed	Any HF dataset format; hundreds of examples upward

Watch out: Its whole design centre is the single-GPU case; multi-GPU and multi-node scaling has historically been the weak spot and is not clearly documented, so a genuinely large training run belongs on Axolotl or TRL with DeepSpeed instead. The kernel-level optimisations mean support for a brand-new architecture sometimes lags upstream transformers by days or weeks, and you are debugging custom kernels when something breaks. The notebook-first culture makes reproducible, versioned production pipelines something you have to build yourself.

Free and open source; you pay only for the GPU you run it on (e.g. $0.49–$0.74/hr for a 4090 or L4 on RunPod, or $0 on a free Colab T4). Paid tiers exist but rates were not retrievable during research. · open source

Axolotl

Axolotl's premise is that the entire pipeline — dataset preprocessing, training, evaluation, quantization and inference — should be driven by one reusable YAML file, which is what makes training runs reproducible and reviewable in git. Its method coverage is the broadest in the open-source field: full fine-tuning, LoRA, QLoRA, GPTQ, QAT across int8/int4/FP8/NVFP4/MXFP4, FP8 mixed-precision training, NVFP4/MXFP4 MoE LoRA, preference tuning (DPO, IPO, KTO, ORPO), RL (GRPO, GDPO) and reward/process-reward modelling. It ships deployment templates for RunPod, Modal, Vast.ai, PRIME Intellect, Novita, JarvisLabs and Latitude.sh.

Methods	Full FT, LoRA, QLoRA, GPTQ, QAT (int8/int4/FP8/NVFP4/MXFP4), FP8 mixed-precision, DPO, IPO, KTO, ORPO, GRPO, GDPO, RM/PRM
Base models	GPT-OSS, Llama, Mistral, Mixtral, Qwen, Gemma and most HF Hub architectures; VLMs incl. LLaVA and Qwen2-VL
Price unit	Free; GPU-hour from your provider
Serving	None — export weights/adapters to vLLM, TGI or LoRAX
Data needed	Many built-in dataset formats; thousands of examples for full FT

Watch out: There is no hosted service and no serving layer — you operate the cluster, the checkpoints and the deployment yourself. The YAML surface is large and under-documented at the edges, so the failure mode is a config that trains successfully and produces a subtly bad model. Broad method coverage also means uneven maturity: the newest quantization and RL paths get less real-world mileage than plain LoRA SFT.

Free, Apache 2.0. Cost is entirely the GPU you rent — commonly $1.59–$3.49/hr for an A100 or H100 on RunPod, or $2.15–$3.85/hr on Nebius. · open source

TRL (Transformer Reinforcement Learning)

TRL is the library the other tools build on, exposing one trainer class per method: SFTTrainer, DPOTrainer, KTO/BCO/CPO/ORPO for offline preference work, GRPOTrainer, RLOOTrainer, OnlineDPO, PPO, NashMD and XPO for online RL, RewardTrainer and PRMTrainer for reward modelling, and a now-stable DistillationTrainer doing on-policy distillation with chunked JSD loss. It reached v1 in March 2026 and integrates with PEFT, DeepSpeed, Liger Kernel and vLLM, with vLLM-accelerated generation on most online methods. Hugging Face names it as one of the recommended replacements for the retired AutoTrain.

Methods	SFT, DPO, KTO, BCO, CPO, ORPO, GRPO, RLOO, OnlineDPO, PPO, NashMD, XPO, RewardTrainer, PRM, Distillation, GKD, MiniLLM
Base models	Any transformers-compatible causal LM or VLM
Price unit	Free; GPU-hour from your provider
Serving	None — vLLM integration is for training-time generation, not deployment
Data needed	Method-specific; prompt/completion for SFT, chosen/rejected pairs for DPO, verifiable rewards for GRPO

Watch out: It is a library, not a pipeline — you write the training script, manage data loading, checkpointing and evaluation yourself, so it is more work than Axolotl for a standard LoRA SFT. A large share of the trainer taxonomy is still marked experimental (PPO, ORPO, KTO, BCO, CPO, NashMD, XPO), meaning APIs move between releases. Online RL methods need enough GPU memory to hold policy and generation simultaneously, which is a much bigger machine than an equivalent SFT job.

Free, Apache 2.0. Cost is your GPU time only. · open source

LLaMA-Factory

LLaMA-Factory covers LoRA, QLoRA, OFT/QOFT, full and freeze tuning, continuous pre-training, preference methods (DPO, KTO, ORPO, SimPO) and PPO across 100+ model families including Llama, Qwen, DeepSeek, Gemma, Mistral, GLM, Phi and multimodal models like LLaVA and Qwen2-VL. Its differentiator is LlamaBoard, a Gradio web UI that runs the whole train/evaluate/infer loop without writing code, which makes it the usual pick for people who wanted AutoTrain's no-code experience. Apache 2.0 with very active development.

Methods	LoRA, QLoRA, OFT, QOFT, full tuning, freeze tuning, continuous pre-training, DPO, KTO, ORPO, SimPO, PPO
Base models	100+ incl. Llama, Qwen3, DeepSeek-R1, Gemma 3, Mistral, GLM, Phi, LLaVA, Qwen2-VL
Price unit	Free; GPU-hour from your provider
Serving	Built-in inference for testing; export to vLLM for production
Data needed	Alpaca or ShareGPT JSON formats; hundreds of examples upward

Watch out: A Gradio UI is a poor fit for production: runs are hard to version, reproduce or schedule, and the click-driven workflow encourages undocumented hyperparameter changes. Documentation quality is uneven and partly Chinese-first. Notably it lists PPO but not GRPO, so it is behind Axolotl, TRL and Unsloth on the RL methods that have become the interesting frontier.

Free, Apache 2.0. GPU cost only. · open source

Hugging Face AutoTrain

AutoTrain Advanced was Hugging Face's no-code training platform spanning NLP, vision, speech and tabular tasks, runnable as a duplicated Space with attached GPU, locally through its UI, or via a Python API. The current documentation opens with an explicit warning: "This project is no longer maintained. No new features will be added and bugs will not be fixed." Hugging Face recommends Axolotl, TRL or transformers.Trainer instead.

Methods	SFT, LoRA, DPO, ORPO, reward modelling; also CV and tabular tasks
Base models	Hugging Face Hub models as of its last release
Price unit	Free package + HF Space GPU hourly
Serving	Push to Hub, then serve separately
Data needed	CSV or JSONL

Watch out: Unmaintained: bugs will not be fixed and new model architectures will not be supported, so anything released after its last commit simply will not train. Even when maintained, its no-code abstraction hid the hyperparameters you most needed to tune, and Space-based training was awkward to monitor and easy to leave running on a paid GPU.

The package is free; running it on a Hugging Face Space required paying for attached GPU hardware. No current pricing is meaningful given the project is unmaintained. · open source · discontinued

LoRAX

LoRAX solves the problem that kills fine-tuning economics: one dedicated GPU per fine-tuned model. It loads LoRA adapters dynamically without blocking in-flight requests and batches requests across different adapters together, so thousands of fine-tunes share a single GPU behind an OpenAI-compatible API, with tensor parallelism, quantization and token streaming. Apache 2.0, so it is the self-hosted route to the serverless-fine-tune economics that Fireworks sells as a service.

Methods	Serving only — consumes LoRA adapters trained elsewhere
Base models	Common open-weight architectures supported by its backend
Price unit	Free; GPU-hour for the host machine
Serving	This is the serving layer — OpenAI-compatible, multi-adapter, streaming
Data needed	None — takes trained adapters, not datasets

Watch out: Its governance is the open question: it originates from Predibase, which has been absorbed into Rubrik, so long-term stewardship is uncertain and you should read the commit history before betting production on it. It serves LoRA adapters only — a full fine-tune gets you nothing from it — and adapter swapping adds latency variance that a single-model vLLM deployment does not have. You are operating an inference server, with all the autoscaling and observability work that implies.

Free, Apache 2.0. Cost is the single GPU you run it on — from $0.49/hr (L40S-class on RunPod Community) to $3.49/hr (H100 SXM). · open source

Modal

Modal turns training into a Python decorator: you define the container image and GPU in code, call a function, and it provisions and bills per second with no charge for idle capacity. That per-second granularity suits fine-tuning's bursty shape — a job runs for two hours a week and costs two hours — and the Starter tier's $30/month credits covers real experimentation. GPUs range from $0.000164/s (T4, roughly $0.59/hr) to $0.001972/s (B300, roughly $7.10/hr), with CPU at $0.0000131/core-second and memory at $0.00000222/GiB-second.

Methods	Any — you run Axolotl, TRL, Unsloth or your own script
Base models	Anything you can pull into a container
Price unit	Per GPU-second ($0.000164–$0.001972/s) plus CPU and memory
Serving	Serverless inference endpoints on the same platform, scale-to-zero
Data needed	Unconstrained — you own the pipeline

Watch out: Per-second rates are higher than a raw GPU cloud — you pay a premium for never paying for idle, which inverts badly for a continuous multi-week training run where a reserved Nebius or RunPod cluster is far cheaper. The Team tier's $250/month base is real money before any compute. GPU concurrency caps (10 on Starter, 50 on Team) constrain large distributed runs, and the programming model is Modal-specific, so moving off it means rewriting your orchestration.

Starter: free, $30/month credits, 3 seats, 100 containers, 10 GPU concurrency. Team: $250/month base with $100/month credits, unlimited seats, 5,000 containers, 50 GPU concurrency. GPUs $0.000164/sec (T4) to $0.001972/sec (B300). CPU $0.0000131/core-sec, memory $0.00000222/GiB-sec, volume storage $0.09/GiB-month.

RunPod

RunPod rents GPU pods across 30+ regions in two tiers: Secure Cloud in vetted datacentres, and Community Cloud from third-party hosts at 15–30% less. Rates run from A40 at $0.49/hr and RTX 4090 at $0.74/hr up through A100 SXM at $1.59, L40S at $1.09, H100 PCIe at $2.89 and H100 SXM at $3.49, all billed per second, and it is the most commonly used target for Axolotl and Unsloth templates. Serverless inference is available separately from $0.58/hr to $9.98/hr for B300-class hardware.

Methods	Any — bring Axolotl, Unsloth, TRL or LLaMA-Factory templates
Base models	Anything you can download
Price unit	Per GPU-hour, billed per second ($0.49–$3.49/hr Secure Cloud)
Serving	Separate serverless inference product, $0.58–$9.98/hr
Data needed	Unconstrained — you own the pipeline

Watch out: Community Cloud's savings come from third-party hosts with correspondingly weaker reliability and security guarantees — not appropriate for regulated or sensitive training data. Capacity for popular GPUs is genuinely unavailable at times, which is disruptive if a job needs to restart. Storage is billed separately and persists (and bills) after your pod is gone, a classic surprise on the invoice, and there is no managed training layer at all.

Secure Cloud per hour: H100 SXM $3.49, H100 PCIe $2.89, A100 SXM $1.59, L40S $1.09, RTX 6000 Ada $0.84, RTX 4090 $0.74, RTX 3090 $0.50, A40 $0.49, L4 $0.49. Community Cloud is 15–30% cheaper. Serverless $0.58–$9.98/hr. Network storage from $0.05/GB/month standard (above 1TB), $0.14/GB/month high-performance.

LoRA (Low-Rank Adaptation)

LoRA freezes the base model and learns a pair of low-rank matrices injected into attention and MLP projections, so you train and ship a few dozen megabytes instead of a full model checkpoint. That is what makes fine-tuning cheap on every platform in this chapter — it is the default on Together, the cheapest tier on Fireworks at $0.50/1M tokens, and the reason a 7B model fits on a 24GB consumer card. Adapters can also be swapped at serving time, which is what LoRAX and serverless multi-LoRA endpoints exploit.

Methods	Parameter-efficient supervised fine-tuning; composes with DPO and GRPO
Base models	Any open-weight transformer; also the default on Together, Fireworks and Nebius
Price unit	Cheapest managed tier ($0.50–$10/1M tokens) or GPU-hour
Serving	Adapters hot-swappable — enables multi-LoRA serving on one GPU
Data needed	Hundreds to a few thousand examples

Watch out: Rank-limited capacity means LoRA is the wrong tool for teaching genuinely new knowledge or shifting a model's behaviour substantially — that needs full fine-tuning or continued pre-training. Results are sensitive to rank and alpha and to which modules you target, so a bad LoRA often reflects configuration rather than data. Stacking or merging multiple adapters degrades unpredictably, and a LoRA is permanently coupled to the exact base checkpoint it was trained against.

Free as a technique. In practice: $0.50–$10 per 1M training tokens on managed platforms, or a few dollars of GPU time self-hosted. · open source

QLoRA

QLoRA quantizes the frozen base model to 4-bit (NF4) and backpropagates through it into LoRA adapters, cutting training memory enough to fine-tune models that would otherwise need multiple datacentre GPUs on a single card. It is the reason Unsloth's free-Colab workflows exist and is supported by Axolotl, LLaMA-Factory, TRL/PEFT and Vertex AI's open-model path. The practical effect is turning a $3.49/hr H100 job into a $0.74/hr RTX 4090 job.

Methods	4-bit NF4 quantized base + LoRA adapters, with paged optimizers
Base models	Any open-weight transformer; supported in Unsloth, Axolotl, LLaMA-Factory, TRL/PEFT, Vertex
Price unit	Single GPU-hour, typically $0.49–$0.74/hr consumer-class
Serving	Usually serve adapters against a 16-bit base; 4-bit serving optional
Data needed	Hundreds to a few thousand examples

Watch out: You pay for the memory saving in wall-clock time — quantized backward passes are meaningfully slower per step than bf16 LoRA, so on a machine that could fit plain LoRA, QLoRA is the wrong choice. Quantization introduces a small but real quality gap versus 16-bit training that matters on precision-sensitive tasks. Merging adapters back into a 4-bit base for deployment is fiddly, and you generally serve against a 16-bit base instead, which means the memory saving does not carry through to inference.

Free as a technique. Real cost is the single GPU: roughly $0.49–$0.74/hr on RunPod, or $0 on a free Colab T4 for small models. · open source

DPO (Direct Preference Optimization)

DPO replaces the reward-model-plus-PPO pipeline of classic RLHF with a single classification-style loss over preference pairs, which is why it became the default alignment method everywhere: OpenAI, Azure AI Foundry, Together, Fireworks, Vertex, TRL, Axolotl and LLaMA-Factory all expose it. You use it after SFT, when the model produces reasonable output but consistently picks the wrong tone, verbosity or emphasis. Fireworks prices it at double the corresponding SFT rate, which is a fair proxy for its cost premium generally.

Methods	Offline preference optimization; variants IPO, KTO, ORPO, CPO, SimPO
Base models	Supported on gpt-4.1 family (Azure), Together, Fireworks, Vertex, and any open model via TRL
Price unit	~2x the SFT per-token rate
Serving	Produces a normal model or adapter — serves like any fine-tune
Data needed	Prompt + chosen + rejected triples; typically 1,000+ pairs

Watch out: It needs paired chosen/rejected data for the same prompt, which is far more expensive to collect than SFT demonstrations and is the reason most DPO projects stall. It is known to over-optimise — pushing down the rejected response's likelihood can degrade fluency and cause verbosity drift — and it cannot teach capability, only preference between things the model can already produce. Running DPO before you have a solid SFT checkpoint reliably wastes the effort.

Free as a technique; roughly 2x SFT cost on managed platforms (Fireworks charges exactly 2x the SFT rate, so $1.00/1M tokens for a ≤16B LoRA). · open source

GRPO (Group Relative Policy Optimization)

GRPO drops PPO's separate value network and instead normalises rewards within a group of sampled completions for the same prompt, which cuts memory substantially and is what made RL training of reasoning models practical outside frontier labs after DeepSeek-R1. It is now first-class in TRL (with vLLM-accelerated generation), Axolotl (alongside GDPO), Unsloth and Vertex AI's RL tuning. It shines where correctness is programmatically checkable: math, code that must compile and pass tests, structured extraction, schema-valid tool calls.

Methods	Online RL with group-normalised advantages; relatives RLOO, GDPO, PPO
Base models	Any open-weight model via TRL, Axolotl or Unsloth; Vertex offers a managed RL path
Price unit	GPU-hour (generation-heavy, multiples of SFT cost)
Serving	Produces a normal model or adapter
Data needed	Prompts plus a programmatic reward function; no labelled outputs required

Watch out: It requires a reward function you can actually write, which excludes most subjective quality goals, and a badly specified reward gets gamed rather than satisfied. It is far more expensive than SFT because every step generates a group of completions, and it is unstable enough that runs need close monitoring — reward can climb while output quality collapses. If you have not exhausted SFT and DPO, GRPO is premature.

Free as a technique. Cost is dominated by generation: expect several times an equivalent SFT run in GPU-hours, so $2.15–$3.85/hr Nebius or $3.49/hr RunPod H100 time for hours to days. · open source

RFT (Reinforcement Fine-Tuning)

RFT is the productised, closed-weight form of reinforcement fine-tuning: you supply prompts and a grader (a scoring function or model grader) rather than labelled outputs, and the platform reinforces high-scoring responses on a reasoning model. It is GA on Azure AI Foundry for o4-mini and, invitation-gated, gpt-5; OpenAI's own version priced it at $100/hour for o4-mini with grading tokens billed separately at the grading model's rate, and its first-party platform is now winding down. Vertex AI offers an equivalent RL tuning path with configurable reward functions, and Nebius lists RFT as a gated professional service.

Methods	Managed reinforcement learning against scoring or model graders
Base models	o4-mini and gpt-5 (Azure, gpt-5 gated); Gemini via Vertex RL tuning; o4-mini on OpenAI while it lasts
Price unit	Per training hour ($100/hr on OpenAI) plus grading tokens
Serving	Provider-hosted endpoints only; no weight export
Data needed	Prompts plus a grader; no labelled outputs, but graders take real engineering

Watch out: Priced by the hour with grading tokens billed on top, so cost is unbounded in a way per-token training is not — this is the easiest way to spend four figures on a fine-tune that loses to a better prompt. It only applies to reasoning models, requires a grader that most teams do not have and get wrong on the first several attempts, and reward hacking is common. Access is narrowing rather than widening: OpenAI's platform is closed to new users, gpt-5 RFT is invite-only on Azure, and Nebius gates it behind sales.

OpenAI (winding down): $100.00/hour of training on o4-mini, plus "tokens used for model grading in reinforcement fine-tuning are billed at that model's per-token rate". Fine-tuned o4-mini inference $4.00 in / $16.00 out per 1M. Azure RFT rates not captured — verify on the Azure OpenAI pricing page.