Train a Custom AI Image LoRA: 12 Steps [2026]

Sofia Lindström
September 5, 2026
21 min read

Every “best AI image generator” list eventually runs into the same wall: none of the big names, not Midjourney, not Flux 2, not Nano Banana Pro, can reliably draw your face, your dog, or your brand’s mascot without a nudge. That nudge is a LoRA. Training one used to require a research background and a rack of GPUs. In September 2026, it takes an afternoon, a folder of 15 to 30 photos, and either a spare gaming GPU or about $2 in cloud credits.

This tutorial walks through the entire process end to end: picking a trainer, building a dataset that won’t sabotage your results, setting hyperparameters for Flux or SDXL, running the job locally or in the cloud, and loading the finished file into ComfyUI. By the end you’ll have a working, reusable LoRA and the troubleshooting knowledge to fix the runs that don’t go as planned.

Don’t miss new tech stories on Google

Add Tech Insider once in the Google app and our stories appear in your news suggestions.

What a LoRA Actually Is, and Why You’d Train Your Own

LoRA stands for Low-Rank Adaptation. Instead of retraining an entire multi-billion-parameter image model, a LoRA trains a small set of extra weight matrices that sit alongside the frozen base model and nudge its output toward a specific subject or style. The result is a file that’s typically 20MB to 400MB, versus the tens of gigabytes a full fine-tune would need.

For AI image generation specifically, a LoRA is what turns a general-purpose model like Flux.1, Flux.2, or SDXL into one that knows your face, a recurring character in your comic, your product’s exact packaging, or a consistent art style across a whole project. This is different from LoRA fine-tuning for large language models, which adjusts a text model’s behavior rather than an image model’s visual output. If you’re looking for the LLM side of LoRA, our guide to fine-tuning LLMs with LoRA covers that separately.

Three use cases drive most LoRA training in 2026: personal portrait LoRAs for consistent AI selfies and headshots, character LoRAs for illustrators and game artists who need the same face across dozens of scenes, and style LoRAs that lock in a specific rendering look for a brand or a comic series. All three follow the same basic pipeline, with differences mainly in dataset size and a couple of hyperparameters.

It also helps to understand what a LoRA is not. It’s not a full copy of the base model, so a Flux.2 LoRA is worthless without Flux.2 installed alongside it. It’s not a face swap or an inpainting mask either, since it changes the model’s underlying weights rather than pasting pixels onto an existing image. And it’s not permanent: you can delete it, retrain it with a cleaner dataset, or load three different LoRAs into the same session without any of them touching the base checkpoint’s original weights. That last property is what makes LoRA training worth the hour it takes, since a bad first attempt costs you nothing but time.

Prerequisites: Hardware, Software, and Accounts You’ll Need

Before starting, decide whether you’re training locally or in the cloud, since the requirements diverge sharply. Here’s what to have ready either way.

• For local training: An Nvidia GPU with at least 12GB of VRAM for SDXL, or 16GB minimum (24GB recommended) for Flux.1/Flux.2. Cards like the RTX 3090, RTX 4080, or RTX 4090 cover most cases.
• Operating system: Windows 10/11 or Linux (Ubuntu 22.04+ is the most tested path for Kohya_ss and ai-toolkit).
• Python: Version 3.10 or 3.11. Newer trainers increasingly assume 3.10+.
• CUDA and drivers: CUDA 12.1 or newer, matched to a recent Nvidia driver.
• Git: Any recent version, used to clone the trainer repository.
• Disk space: At least 40GB free for base model weights, dependencies, and checkpoints.
• For cloud training: A fal.ai account with billing enabled, or a Civitai account with Buzz credits (Civitai’s in-platform currency).
• For testing results: ComfyUI installed locally, or access to a hosted ComfyUI instance. If you haven’t set this up yet, see our guide to running Flux locally in ComfyUI.
• A trainer of choice: Kohya_ss (sd-scripts) for SD 1.5 and SDXL, ai-toolkit by Ostris for Flux.1 and Flux.2, or OneTrainer if you want one GUI that spans all of them.

You do not need all of this at once. If you’re only going the cloud route through fal.ai or Civitai, skip the GPU and CUDA requirements entirely and jump to Step 7. One more thing worth having ready before you start: a captioning workflow. Manually typing 20-30 descriptions is tedious enough that most people either use a vision-language model to draft captions and hand-edit them, or lean on a dedicated captioning tool bundled into their trainer’s GUI. Neither is required, but skipping it usually means rushed, inconsistent captions, which is one of the pitfalls covered later in this guide.

Step 1: Decide Between Local and Cloud Training

This decision shapes everything that follows, so make it first. Local training costs nothing beyond electricity once you own the hardware, gives full control over every setting, and keeps your training images off third-party servers. The tradeoff is setup time and a real GPU requirement. Cloud training removes the hardware barrier entirely: fal.ai’s fast Flux trainer runs for about $2 per job and finishes in a couple of minutes, while Civitai bills in Buzz credits starting around 500 Buzz (roughly $0.50) for SD 1.5 or SDXL and slightly more for Flux-based models.

A practical rule: if you have a 16GB+ VRAM GPU sitting idle and want to iterate on settings repeatedly, train locally. If you have a laptop or a lower-VRAM card, or you just want one clean LoRA without touching a config file, use fal.ai or Civitai’s on-site trainer.

There’s a third option worth mentioning for anyone stuck between the two: rented cloud GPUs through providers that charge by the hour rather than by the training job, with L40 or A100-class instances running roughly $0.40-$1.60 per hour depending on the provider. This puts a full Kohya_ss or ai-toolkit setup on rented hardware, giving you the same fine-grained control as local training without owning a GPU. It’s more setup work than fal.ai’s one-call API, but cheaper than paying per-run if you expect to train many LoRAs over time. If you’d rather quantize the base model down to fit a smaller local GPU instead of renting, our guide to GGUF model quantization covers the general technique, though note that image-model quantization for training uses int8/NF4 formats rather than GGUF specifically.

Step 2: Choose the Right Trainer for Your Base Model

Not every trainer supports every base model equally well, and picking the wrong one wastes hours. Kohya_ss (built on the sd-scripts codebase) remains the most documented option for Stable Diffusion 1.5 and SDXL, with the largest body of community configs to copy from. Ostris’s ai-toolkit has become the default recommendation for Flux.1 and the newer Flux.2 family, including the lightweight Flux.2 Klein models. OneTrainer sits in between: a single GUI that covers SD 1.5, SDXL, Flux.1, and Flux.2, which is convenient if you plan to train LoRAs for more than one base model.

If you’re training against Flux.2 specifically, it’s worth knowing what the base model was built for. Black Forest Labs’ own documentation describes it directly: the model can “generate photorealistic images with precise control over colors, poses, and composition, or edit existing images by referencing up to 10 sources simultaneously” (Black Forest Labs, FLUX.2 overview). A LoRA trained on top of Flux.2 inherits that reference-editing capability, which is part of why it’s become the preferred base for character work in 2026.

Step 3: Build a Training Dataset That Won’t Sabotage You

Dataset quality matters more than any hyperparameter you’ll tune later. For a character or likeness LoRA, aim for 15 to 30 images. Fewer than 10 usually under-trains the identity. More than 80 for a simple subject risks the model memorizing backgrounds instead of learning the subject. Style LoRAs, which need to generalize across many subjects, typically want a wider range of 30 to 80 images.

Vary the angles, lighting, expressions, and backgrounds as much as possible while keeping the subject consistent. A dataset of 20 photos taken in the same room under the same lighting will produce a LoRA that bakes in that room and that lighting, not just the face. Crop or resize everything to a consistent resolution, with 1024×1024 as the safe default for both SDXL and Flux-era models. Discard anything blurry, heavily compressed, watermarked, or oddly cropped, since diffusion trainers pick up on these artifacts just as readily as they pick up on your subject’s features.

• Character/likeness LoRA: 15-30 images, varied angles and expressions
• Style LoRA: 30-80 images, varied subjects in the same style
• Resolution: 1024×1024, consistent across the set
• Format: JPEG or PNG, no watermarks or heavy compression artifacts

Step 4: Caption Every Image Correctly

Captioning is where most first-time LoRA trainers lose quality without realizing it. The older Stable Diffusion convention of dumping comma-separated tags (“woman, brown hair, outdoors, smiling”) still works for SD 1.5 and SDXL, but Flux-era trainers respond better to natural-language sentences that describe the full scene, similar to how you’d prompt the model itself. Civitai’s 2026 training guidance for Flux 2 specifically recommends natural-language captions generated through tools like JoyCaption rather than tag lists.

Every caption should include a unique trigger word or short phrase that doesn’t collide with existing vocabulary, such as “sks_person” or “zxq_style.” This is what you’ll type later to activate the LoRA. Describe what varies from image to image (pose, lighting, clothing, background) and let the trigger word carry the constant identity or style. Since Flux models don’t support negative prompts the way older architectures do, captions need to be precise about what’s actually in frame rather than relying on exclusion. Black Forest Labs states this outright in its own prompting guide: “FLUX.2 does not support negative prompts. Focus on describing what you want, not what you don’t want” (Black Forest Labs, FLUX.2 prompting guide). The same discipline applies when writing training captions for a Flux-based LoRA.

# Example caption for a character LoRA (Flux/ai-toolkit style)
# File: 001.txt (paired with 001.jpg)
zxq_person, a young woman with short brown hair standing in a park,
wearing a blue jacket, soft afternoon light, three-quarter angle

# Example caption for the same subject, SDXL/Kohya tag style
# File: 001.txt
zxq_person, 1girl, brown hair, short hair, blue jacket, outdoors, park, smiling

Step 5: Install and Launch a Local Trainer

If you’re training on Flux with ai-toolkit, clone the repository and install dependencies inside a virtual environment. The commands below assume a Linux or WSL environment with CUDA already installed.

git clone https://github.com/ostris/ai-toolkit.git
cd ai-toolkit
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# Log in to Hugging Face to pull the Flux base weights
huggingface-cli login

For SDXL or SD 1.5, Kohya_ss is the more battle-tested choice. Its GUI wrapper (maintained by bmaltais) sits on top of the sd-scripts training engine.

git clone https://github.com/bmaltais/kohya_ss.git
cd kohya_ss
python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt
accelerate config

# Launch the local web GUI
python kohya_gui.py --listen 127.0.0.1 --server_port 7860

The accelerate config step asks a short series of questions about your GPU setup. For a single-GPU consumer machine, the defaults (no distributed training, mixed precision fp16 or bf16) are correct almost every time.

Step 6: Set the Core Hyperparameters

Four settings do most of the work: network rank (also called LoRA rank or network dim), learning rate, total training steps, and batch size. Get these roughly right and the rest of the defaults will carry you through a usable first LoRA.

Lower rank produces a smaller file and a more subtle effect. Higher rank captures more detail but risks overfitting on a small dataset and takes longer to train. For a 20-image character LoRA on Flux.2, rank 16 with 2,000 steps is a sensible starting point. If results look underbaked after testing, retrain at rank 32 rather than just adding more steps at the same rank.

One setting that trips up first-timers is alpha, which sits alongside rank in nearly every trainer’s config and controls how strongly the LoRA’s learned weights get scaled during inference. The common convention is to set alpha equal to rank (both at 16, or both at 32), which produces a neutral scaling factor of 1.0. Setting alpha lower than rank softens the LoRA’s effect even at full strength, which can help if your results consistently look overcooked. Setting it higher amplifies the effect, which occasionally helps a stubbornly under-trained LoRA without a full retrain. Most configs, including the ai-toolkit example below, default to a 1:1 ratio, and there’s little reason to deviate from that until you’ve trained a few LoRAs and have a feel for how your specific dataset behaves.

# ai-toolkit config snippet (config/my_lora.yaml)
config:
  name: "zxq_person_flux"
  process:
    - type: "sd_trainer"
      training_folder: "output"
      device: cuda:0
      network:
        type: "lora"
        linear: 16
        linear_alpha: 16
      save:
        dtype: float16
        save_every: 250
      train:
        batch_size: 1
        steps: 2000
        lr: 1e-4
        optimizer: "adamw8bit"
      model:
        name_or_path: "black-forest-labs/FLUX.2-dev"
      datasets:
        - folder_path: "datasets/zxq_person"
          caption_ext: "txt"
          resolution: [1024]

Step 7: Launch a Cloud Training Job Instead

If you skipped straight here because you don’t have a suitable GPU, fal.ai and Civitai both offer trainers that need nothing more than a dataset zip file and a credit card. fal.ai’s FLUX LoRA Fast Training endpoint bills at roughly $2 per training run, scaling linearly if you increase step count, and typically finishes in a few minutes. A general-purpose fal.ai Flux trainer bills per step instead, at about $0.005 per step, or roughly $1 for 200 steps.

curl -X POST https://queue.fal.run/fal-ai/flux-lora-fast-training 
  -H "Authorization: Key $FAL_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "images_data_url": "https://your-storage.example.com/zxq_person_dataset.zip",
    "trigger_word": "zxq_person",
    "steps": 1000
  }'

Civitai’s on-site trainer runs entirely in the browser: upload a zip of images and captions, pick a base model (SD 1.5, SDXL, Flux, or Flux.2 Klein), and confirm the Buzz cost shown before you submit. Pricing starts at 500 Buzz for SD 1.5/SDXL jobs, with Flux.2 Klein 4B training around 500 Buzz and the larger Klein 9B variant around 1,000 Buzz. As the platform’s own education page puts it, the trainer is “open to all users,” with the exact cost shown up front before you commit a job (Civitai, LoRA Trainer documentation).

Step 8: Monitor Training and Read the Sample Grid

Most trainers generate a grid of sample images at fixed intervals (every 250-500 steps is typical) so you can watch the LoRA learn in real time instead of waiting until the end. Kohya_ss and ai-toolkit both write these samples to an output folder, and Civitai/fal.ai display them in the job dashboard as the run progresses.

Watch for two failure signs early. If samples at step 500 already look nearly identical to your training photos with no variation in pose or background, you’re heading toward overfitting and should consider stopping early or lowering the learning rate for the next attempt. If samples at step 1,500 still barely resemble the subject, the LoRA is under-trained. Typical console output during a healthy run looks like this:

Epoch 3/10, step 600/2000, loss: 0.0847
Saving checkpoint: zxq_person_flux-000600.safetensors
Generating sample images...
Epoch 4/10, step 800/2000, loss: 0.0691
Saving checkpoint: zxq_person_flux-000800.safetensors

Loss trending downward is a good sign, but don’t chase the lowest possible number. A LoRA with loss that keeps dropping past step 2,000 on a 20-image dataset is usually memorizing rather than generalizing.

What Good and Bad Output Actually Looks Like

It helps to know what you’re aiming for before you generate your first test batch. A well-trained character LoRA at step 1,500-2,000 should produce images where the subject’s face stays recognizable across at least four or five different poses, lighting setups, and outfits, while everything else in the frame (background, clothing details, secondary objects) changes freely between generations. If you prompt “zxq_person reading a book by a window” and “zxq_person standing on a beach,” both should clearly show the same person in genuinely different scenes rather than two nearly identical photos with the background swapped in.

Bad output tends to fall into one of two visible patterns. Under-trained LoRAs produce a subject that resembles a generic version of the prompt with only a faint resemblance to your training photos, as if the trigger word barely registered. Overfit LoRAs do the opposite: every output looks like a slight variation on one specific training photo, with the same pose, same framing, and same background bleeding through regardless of what the prompt asks for. Both are fixable, and both point back to the dataset and step-count choices from Steps 3 and 6 rather than anything wrong with the base model itself.

Step 9: Load and Test Your LoRA in ComfyUI

Once training finishes, you’ll have a .safetensors file, usually a few hundred megabytes for a Flux LoRA at rank 16-32, or considerably smaller for SDXL. Copy it into ComfyUI’s LoRA folder:

cp zxq_person_flux.safetensors ComfyUI/models/loras/

# Then restart ComfyUI, or refresh the node list if it's already running

In the ComfyUI graph, add a “Load LoRA” node between your checkpoint loader and your sampler, select the new file from the dropdown, and set strength to 0.8 as a starting point. Prompt using your trigger word exactly as it appeared in training captions (“a photo of zxq_person hiking in the mountains”) and generate a batch of four to six images to judge consistency. If you haven’t built a Flux or SDXL workflow in ComfyUI before, our ComfyUI workflow tutorial covers the node graph basics this step assumes.

Step 10: Tune Strength and Fix Weak Results

LoRA strength controls how much influence the trained weights have over the base model’s output, on a scale that typically runs from 0 to 1.5. At 1.0, you’re applying the full trained effect. Values around 0.6-0.8 often produce more natural results for likeness LoRAs, since full strength can occasionally push skin texture or facial proportions into an over-processed look.

If the subject looks right but every generated image shares an odd artifact (the same weird shadow, a strange background element), that artifact was probably present across multiple training photos and got baked in. If the subject doesn’t look like your training photos at all even at strength 1.0, the LoRA under-trained and needs more steps, a higher rank, or a cleaner dataset.

Step 11: Package, Back Up, and Share Your LoRA

The finished .safetensors file is self-contained and portable across any tool that supports the same base model architecture (a Flux.2 LoRA won’t work on an SDXL checkpoint and vice versa). Keep a copy of the training config alongside the weights file so you can reproduce or tweak the run later, since re-deriving the exact hyperparameters from a finished file after the fact isn’t possible.

If you plan to publish the LoRA publicly, Civitai remains the largest community hub for this and handles versioning, sample galleries, and licensing tags automatically when you upload through the same account you trained with. For personal or client work, a private cloud folder or local backup is enough, given how small the files are.

Hugging Face’s Diffusers library documents a parallel path worth knowing about if you’re building your own training or inference scripts rather than relying on a GUI trainer: its LoRA guide shows how to load and merge trained weights directly in Python using the same underlying peft-style adapter format that Kohya_ss and ai-toolkit both export to (Hugging Face, Diffusers LoRA training guide). This matters if you ever want to fold a LoRA’s effect permanently into a merged checkpoint instead of loading it separately every session, though for most single-subject or single-style use cases, keeping it as a standalone file you can toggle on and off is simpler and more flexible.

Step 12: The Complete Project, a Personal Portrait LoRA End to End

Putting every step together, here’s the full path for a realistic personal portrait LoRA using the cloud route on fal.ai, which needs no local GPU:

1. Collect 20 photos of yourself: varied angles, lighting, expressions, and backgrounds. Crop to roughly 1024×1024.
2. Write one natural-language caption per photo in a matching .txt file, each starting with your chosen trigger word.
3. Zip the images and captions together (images and .txt files at the top level, not in a subfolder).
4. Upload the zip to any public or signed storage URL fal.ai’s endpoint can reach.
5. Submit the training job via the curl command from Step 7, with steps set to 1500 for a character LoRA of this size.
6. Wait for the job to complete, typically a few minutes, and download the resulting .safetensors file.
7. Copy the file into ComfyUI/models/loras/ and restart ComfyUI.
8. Build a simple text-to-image graph with your base checkpoint, the LoRA loader at strength 0.8, and a prompt using your trigger word.
9. Generate a batch of six images and compare consistency across poses.
10. If results are weak, retrain with steps raised to 2000, or rebuild the dataset with more varied backgrounds.

Total cost for this project on fal.ai at 1,500 steps runs around $7.50 at the general-purpose per-step rate, or roughly $2-3 using the fast-training endpoint. Total hands-on time is under an hour, most of it spent curating the 20

Common Pitfalls When Training an AI Image LoRA

• Too few or too repetitive images. Ten photos taken in one sitting under one light source teach the model that lighting, not just the subject.
• Overfitting from too many steps. Pushing a 15-image dataset to 4,000+ steps at high rank almost always memorizes backgrounds and clothing instead of generalizing.
• Tag-dump captions on a Flux base. Flux-family models respond better to descriptive sentences than to comma-separated tag lists inherited from older SD 1.5 workflows.
• Inconsistent resolution and aspect ratio. Mixing portrait, landscape, and square crops in the same dataset without a bucketing setup degrades output sharpness.
• Wrong rank for your VRAM. Setting rank 64 on an 8GB card without quantization is a common cause of out-of-memory crashes partway through a run.
• Skipping the trigger word. Forgetting to include a unique trigger word in captions makes it impossible to selectively activate the LoRA later without also affecting unrelated generations.

Troubleshooting Guide: LoRA Training Errors and Fixes

1. CUDA out of memory during training. Lower batch size to 1, drop network rank, or switch to an int8/NF4 quantized base model. Flux LoRA training can need over 30GB unquantized but drops to around 9-13GB with NF4/int4 quantization.
2. Training completes but the LoRA has no visible effect. Check that you’re loading the LoRA with the matching base checkpoint architecture, and confirm the trigger word in your test prompt exactly matches the one used in captions.
3. Generated faces look distorted or “melted.” Strength is likely too high. Drop to 0.6-0.7 and regenerate.
4. All outputs look nearly identical to training photos. Classic overfitting. Retrain with fewer steps, a lower rank, or a larger, more varied dataset.
5. Kohya_ss GUI won’t launch after install. Confirm the virtual environment is activated before running kohya_gui.py, and check that the accelerate config step completed without errors.
6. ai-toolkit fails to download base model weights. Run huggingface-cli login again and verify you’ve accepted the model’s license terms on Hugging Face’s site, since gated models silently fail to download otherwise.
7. Cloud training job fails validation before starting. Most commonly a malformed zip file. Confirm images and .txt caption files sit at the top level of the archive, not nested in a subfolder.
8. LoRA works in ComfyUI but not in another UI (Automatic1111/Forge). Confirm the LoRA folder path is correct for that specific UI and that the UI’s own model loader supports the same base architecture the LoRA was trained against.
9. Training loss plateaus immediately and never drops. Learning rate is likely too low for the dataset size, or captions are inconsistent enough that the model can’t find a stable pattern to learn.

Advanced Tips for Sharper, More Flexible LoRAs

Once a basic LoRA works, a few refinements separate a usable file from a genuinely reliable one. Training at multiple resolutions with bucketing (rather than force-cropping everything to one exact size) preserves more of each source photo’s framing and tends to produce more natural compositions. Saving checkpoints every 250 steps rather than only at the end lets you compare several points along the training curve and pick the least overfitted version instead of assuming the last checkpoint is the best one.

For character work specifically, mixing in two or three images with the subject at a smaller scale in the frame (not just tight headshots) noticeably improves the LoRA’s ability to generate full-body shots later. And when writing prompts against a Flux-based LoRA, structure matters. Black Forest Labs recommends a consistent framework in its own documentation: “Use this framework for consistent results: Subject + Action + Style + Context” (Black Forest Labs, FLUX.2 prompting guide). Applying that same structure to your training captions, not just your generation prompts, tends to produce more predictable results once the LoRA is loaded.

If you’re training multiple LoRAs for related characters or a shared style across a project, keep hyperparameters identical between runs and only change the dataset. This makes it possible to combine two LoRAs at partial strength later (a character LoRA at 0.8 alongside a style LoRA at 0.5) with predictable, additive results rather than one overpowering the other unpredictably.

It’s also worth reading beyond any single tutorial, including this one, before locking in your settings for a large or important project. The LoRA training community has iterated on these techniques for years, and long-running community writeups like Civitai’s own opinionated training guide track configuration changes and caveats that a single snapshot in time can’t fully capture (Civitai, opinionated guide to LoRA training). Treat the numbers in this tutorial as a reliable starting point, not a ceiling.

Local vs Cloud LoRA Training: Which Should You Use?

There’s no universally correct answer here, only a tradeoff between cost, control, and convenience. Local training through Kohya_ss, ai-toolkit, or OneTrainer is free after the initial hardware investment and gives full access to every hyperparameter, but demands a GPU with real VRAM headroom and a setup process that can eat an evening the first time through. It also means your training photos, which for a personal likeness LoRA are often your own face, never leave your machine.

Cloud training through fal.ai or Civitai removes the hardware and setup barrier almost entirely. A single training run costs less than a fast-food meal and finishes before you’d get through installing a local trainer’s dependencies. The tradeoff is that your dataset gets uploaded to a third party, and per-run costs add up if you’re iterating through many dataset or hyperparameter variations. Testing the resulting LoRA is identical either way, and if you want to compare how a custom-trained LoRA stacks up against the base models it’s built on, our guide to testing AI image generators covers a repeatable evaluation process. For a broader look at how the base models themselves compare before you commit to training against one, see our AI image generator comparison.

Frequently Asked Questions

How many images do I actually need to train a good LoRA?

For a character or personal likeness LoRA, 15 to 30 well-varied images is the practical sweet spot. Style LoRAs, which need to generalize across different subjects, typically want 30 to 80 images covering a range of compositions in that style.

Can I train a LoRA without owning a GPU?

Yes. fal.ai’s FLUX LoRA Fast Training endpoint and Civitai’s on-site trainer both run entirely in the cloud. A basic run costs roughly $2 on fal.ai or from 500 Buzz (about $0.50) on Civitai, with no local hardware required.

What’s the difference between training a LoRA for Flux versus SDXL?

The core process is the same, but recommended settings differ. Flux-family LoRAs typically use a lower rank (16-32) and respond better to natural-language captions, while SDXL LoRAs often use a higher rank (32-64) and still work well with traditional comma-separated tag captions.

How long does LoRA training actually take?

On a cloud trainer like fal.ai, a fast character LoRA can finish in a couple of minutes. Locally, a midrange consumer GPU training a few thousand steps can take anywhere from under an hour to several hours, depending on the GPU, dataset size, and step count.

Why does my LoRA only work well at certain prompts?

This usually points to a dataset that lacked variety. If every training photo showed the subject in a similar pose or setting, the LoRA learns to associate the trigger word with that narrow context rather than the subject in isolation.

Is it legal to train a LoRA on someone else’s likeness?

Training a LoRA on your own photos is unambiguous. Training on someone else’s likeness without consent raises the same rights-of-publicity and consent issues as any other use of a person’s image, and platforms like Civitai have their own content policies governing what can be uploaded publicly. When in doubt, keep third-party likeness LoRAs private and get explicit consent from the subject.

Can I combine multiple LoRAs in a single generation?

Yes, most UIs including ComfyUI support loading several LoRAs at once, each at its own strength setting. A character LoRA and a style LoRA can be layered together, though pushing both to full strength simultaneously often produces conflicting artifacts, so partial strengths (0.6-0.8 each) usually blend more cleanly.

My trained LoRA file is huge. Is that normal?

A Flux LoRA at rank 16-32 typically lands between 100MB and 400MB, larger than the 20-80MB files common with SD 1.5 LoRAs, because Flux’s underlying transformer architecture has substantially more layers that the adapter weights attach to. This is expected and not a sign of a misconfigured run.