What a LoRA actually is (plain English)
A LoRA (Low-Rank Adaptation) is a small file — typically 50-200MB — that teaches an AI image model one specific thing. For character consistency, that thing is "what this specific face looks like."
Here's the mental model: the base image model (SDXL, FLUX, etc.) is a giant general-purpose model that knows what faces look like in general. The LoRA is a small addendum that tells it "when you see this trigger word in the prompt, specifically generate THIS face" — the face it learned from your reference photos. Load the LoRA alongside the base model, include the trigger word in your prompt, and every generation locks identity to the trained face.
The process to train one: give the training tool 15-25 reference photos of the person, pick training parameters (rank, alpha, learning rate, scheduler — each needs the right value), run training for 2-4 hours on a GPU, test the result, usually iterate.
Why Kohya is the "standard" (and why that's not helpful for most people)
Kohya SS is a training tool wrapper around the underlying LoRA training code. It's the de-facto standard — most tutorials point at it, most model-sharing sites host Kohya-trained files, most ComfyUI workflows assume Kohya-trained LoRAs.
What Kohya requires:
1. Dataset curation. 15-25 reference photos of the specific face. Variety in angles, lighting, and expressions matters. Too similar and the model overfits (every output looks like the one angle you provided). Too varied and the model underfits (face doesn't lock reliably). Hours to curate well.
2. Config file setup. Rank (how big the LoRA file is — 8/16/32/64/128 are common choices). Alpha (training strength relative to rank — usually half the rank). Learning rate (how fast the model updates — 1e-4 is a common starting point). Scheduler (how the learning rate changes over time). Network modules (which parts of the model get updated). About 15 parameters that each need the right value or the training fails silently.
3. GPU access. 24GB VRAM minimum for comfortable training. If you don't have that hardware, rent via RunPod or similar ($5-20 per training run depending on duration).
4. Iteration. First LoRA usually overfits or underfits. Expect 3-5 attempts before you get a usable one. That's $15-100 in GPU rental and 10-20 hours of iteration time.
Total realistic time for a non-developer: 20-40 hours to train your first usable LoRA. For a working developer who already understands the underlying concepts, 5-10 hours. For a complete beginner, often longer.
The hosted alternatives — what they actually do
Several hosted options exist that abstract some or all of Kohya's complexity.
Replicate LoRA training endpoint. Pay-per-training ($2-5 per LoRA). API-first (you call it from your code, not a UI). Picks safe defaults for the config parameters you'd otherwise set manually. Still requires dataset curation on your end. Right if you're a developer building an app on top of training infrastructure. Still too technical for end-user consumers.
Fal LoRA trainer. Similar shape to Replicate — pay-per-training, API-first, safe defaults, developer-oriented. Pricing comparable ($2-5 per LoRA). Choice between the two depends on which API ergonomics you prefer and what's already in your stack.
Astria.ai. Consumer-facing UI (upload photos through a web form, no API required). Priced per avatar pack rather than per training ($0.99-8/pack depending on tier). Targeted at avatar / profile picture use cases rather than general character consistency. Right if your use case is profile pictures; not ideal for broader creative work.
AI companion apps with custom-persona builders (Sloane, and others in the category). Full UI, no API required. Upload 1-5 reference photos through the custom-persona builder, click a button, wait ~10 minutes, generate forever with locked identity. Included in subscription ($19.99/mo for Sloane Premium — unlimited custom personas). Right if your use case is specifically "character I've designed, for a persona-companion workflow."
Self-hosted easier-than-Kohya tools. OneTrainer and SimpleTuner are community alternatives to Kohya with slightly friendlier UI. Still require the GPU, still require config knowledge. Marginal improvement over Kohya; still a developer-oriented learning curve.
The actual quality comparison
Honest take on where each option lands.
Kohya DIY. Highest ceiling if you have the time and skill to tune it. Lowest floor — your first several attempts will be visibly worse than hosted alternatives' first attempts. Payoff is 5-10 training runs in: you learn which config values work for your specific face types, you develop dataset-curation intuition, you can get results no hosted service matches. For users who want absolute control, worth it. For users who just want a working LoRA, not worth it.
Replicate / Fal. Safe defaults abstract the config decision. Quality is roughly "average Kohya result from a technically-competent user" — not the best possible, consistently better than beginner Kohya attempts. Right for developers who want programmatic LoRA generation without becoming a Kohya expert.
Astria. Narrow but polished. Good for avatar / headshot use cases specifically. Doesn't generalize well to full-body or scene-varied applications.
AI companion apps. Safe defaults tuned specifically for the persona-companion use case. Quality is high within that scope (consistent face across scenes, outfits, settings) and consumer-ready (no technical knowledge required). Not useful outside the persona-companion scope.
For 90% of users who want "same face across many scenes," hosted options with safe defaults produce better results than their first 5 Kohya attempts. For the 10% who have specific creative needs beyond standard character consistency, Kohya is still worth learning.
The specific pricing honest comparison
| Approach | Setup time | Per-training cost | Subscription | Right for |
|---|---|---|---|---|
| Kohya DIY (local GPU) | 20–40 hrs learning | $0 after hardware | $0 | Full control, 5+ year horizon, you enjoy the tooling |
| Kohya DIY (rented GPU) | 20–40 hrs learning | $5–20 per training run | $0 | Full control without the hardware investment |
| Replicate LoRA endpoint | 2–4 hrs API integration | $2–5 per LoRA | Pay-per-use | Developer building on training infrastructure |
| Fal LoRA trainer | 2–4 hrs API integration | $2–5 per LoRA | Pay-per-use | Developer building on training infrastructure |
| Astria.ai | 15 min signup | $0.99–8/avatar pack | Pay-per-pack | Avatar / headshot use cases specifically |
| Sloane custom-persona | 10 min signup | $0 | $19.99/mo Premium (unlimited new personas) | AI companion / persona-first use case |
The honest math for most users: hosted options cost less than the time investment of learning Kohya for anyone who values their time at more than ~$10/hr. The exception is users who enjoy the tooling itself, which flips the calculation entirely.
If you want an AI companion specifically
If the specific thing you're trying to accomplish is "I want to make an AI version of a specific woman I've designed — her face, in different outfits and settings, with chat and voice that match the character" — that's not a LoRA-training project. It's an AI companion app use case, and the category exists.
Sloane is one option in the category. The custom-persona builder trains a per-persona LoRA from 1-5 reference photos in ~10 minutes. Every subsequent generation on that persona uses the trained model, so her face is locked across every photo. The whole stack — chat, memory, image gen, voice, video — all runs on the trained persona. Pricing: Free · Plus $9.99 · Premium $19.99 (unlimited custom personas on Premium).
Other options in the AI companion category exist too; comparison guides are available for the honest side-by-side. The point of this section is: if your use case is persona-companion-shaped, you don't need to assemble the LoRA training yourself. The category productized it years ago.
