How to Train a LoRA Model Locally

How to Train a Custom LoRA Model Locally with Stable Diffusion and Flux

Training a custom LoRA locally gives you something no cloud tool can offer: a model trained on your exact subject, running privately on your own hardware, with no per-generation cost and no content restrictions. Whether you want to teach an AI to replicate a specific art style, generate consistent characters, or recreate a product or face, local LoRA training is how you do it.

This guide covers the complete process for training LoRA models using Flux — currently the strongest open-source architecture for local training — running on your own GPU. No Python setup required if you use Promptus, which handles the environment automatically.

What you need before you start: hardware and software requirements

Training a LoRA model locally requires a compatible NVIDIA GPU with at least 12GB VRAM for Flux-based training. You can train with 8GB VRAM using lower-resolution datasets, but expect longer training times and some quality tradeoffs. AMD GPUs are supported via ROCm on Linux but require additional configuration.

GPU requirements

Software setup

The simplest way to set up a local LoRA training environment is through Promptus, which installs all dependencies — CUDA, Python, the trainer nodes, and model management — in a single download. Manual setup via Python is also possible but requires Git and several additional installation steps.

• Promptus (Windows or Mac): one-click install, handles all dependencies automatically.
• Base Flux model files (flux1-dev.safetensors or the FP8 variant for lower VRAM).
• CLIP text encoders: clip_l.safetensors and t5xxl_fp8_e4m3fn.safetensors.
• VAE file: ae.safetensors.
• Training images: 20-50 images at 1024×1024 resolution (JPG or PNG).

---

How to prepare your training dataset

Dataset quality determines LoRA quality. A poorly prepared dataset — images with inconsistent lighting, mixed subjects, or wrong resolution — produces a model that generates inconsistent or blurry results. Spending time on dataset preparation is the highest-return part of the entire process.

Image selection guidelines

1. Use 20-50 images of your subject. Fewer than 20 often under-trains; more than 80 can cause over-fitting where the model memorizes instead of learning.
2. Use consistent image resolution. All images should be 1024×1024 pixels. Crop and resize before training — mixed resolutions confuse the trainer.
3. Vary the composition, not the subject. Use different angles, lighting, backgrounds, and distances for the same subject. This teaches the model to generalize, not memorize.
4. Remove duplicates and near-duplicates. Two nearly identical images count as one data point but waste training cycles.
5. Name your trigger word. Choose a unique word that will activate your LoRA in prompts — something unlikely to appear in standard prompts, like mysubject01 or studioaxyz.

Writing image captions (optional but recommended)

Captioning your training images teaches the model the relationship between text descriptions and visual content. This improves prompt responsiveness in your finished LoRA. You can generate captions automatically using the BLIP or Florence captioning workflow, or write them manually.

Each caption should describe the image accurately and include your trigger word. Example: "mysubject01, a woman with dark hair wearing a red jacket, standing in a forest, natural lighting, photorealistic."

Tip: Caption format matters

Put the trigger word first in every caption. This associates it most strongly with the subject. Generic descriptions of environment, lighting, and style at the end of each caption improve the LoRA's flexibility across different prompts.

---

Step-by-step: how to train stable diffusion LoRA locally

The following steps use Promptus to manage the workflow environment. If you are using a manual Python setup, the trainer parameters are identical — only the interface for loading and running the workflow differs.

1. Open your workspace and load the layout. Navigate to the Workflows tab. Search for "LoRA trainer" or "Flux trainer" in the workflow library. Download the Flux LoRA training workflow.

2. Install required nodes. When the workflow loads, any missing nodes will be flagged automatically. Click "Install Missing Nodes" and restart the workflow environment when prompted.

3. Set your dataset path. In the trainer workflow, find the Dataset Path field and point it to the folder containing your training images. Use the full path, not a relative one — this prevents the most common training error.

4. Configure your output name. Set a memorable name for your LoRA file. This becomes the filename (e.g., mystyle_v1.safetensors) and should reflect the subject or style you're training.

5. Connect the Flux model. In the workflow, link your flux1-dev.safetensors model to the model loader node. Also connect the CLIP encoders and VAE to their respective nodes. If connections appear as red dashed lines, a model file is missing from the expected folder.

6. Set training steps. For a 30-image dataset, 1,500-2,000 steps is a good starting point. More steps increases training time but can improve quality up to a point — beyond ~3,000 steps for small datasets, quality typically degrades due to over-fitting.

7. Set learning rate. Leave at the default (typically 0.0001 or 1e-4) for your first training run. Only adjust this after reviewing your first results.

8. Click Run. Training will begin. You'll see step progress, training loss values, and preview images at regular intervals.

What to watch during training

Training loss should decrease steadily over the first 30-40% of steps, then level off. A steadily decreasing loss that never levels off usually means under-training — increase your steps. A loss that drops very fast then starts increasing means over-fitting — reduce your steps or increase your dataset size.

Preview images should begin resembling your subject by around step 800-1,000 for a 30-image dataset. If they look completely random at step 1,500, check that your dataset path is correct and that captions are loading properly.

---

How to test your trained LoRA after training completes

When training finishes, the LoRA file (a .safetensors file, typically 50-200MB) will be saved to the output location you specified. Load it into a standard image generation workflow to test it.

1. Load the core generator. Open a basic text-to-image workflow inside your local application environment.

2. Apply the patch. Add a LoRA loader node and point it to your newly trained file.

3. Dial in the weight parameters. Set the LoRA strength to 0.8 as a starting point. Values closer to 1.0 apply the LoRA more strongly; values near 0.4-0.5 blend it more subtly with the base model.

4. Write a test prompt using your trigger word. Use the structure: [trigger word], [description of desired output]. Test with 3-4 different prompts to assess how well the LoRA responds.

5. Evaluate performance. Compare outputs with the LoRA enabled and disabled. Your subject or style should be clearly visible when enabled and absent when disabled.

If results are not matching your expectations, the most common issues are: LoRA strength too low (increase to 0.9-1.0), trigger word not in the prompt (add it explicitly at the start), or under-training (retrain with more steps or a larger dataset).

---

Troubleshooting: LoRA not showing up or not working

LoRA not showing up in your generation results is the most frequently reported training issue. It almost always has one of four causes.

LoRA file not in the correct folder

The LoRA loader looks for files in a specific directory — typically models/loras/. If your trained file is saved elsewhere, it will not appear in the LoRA selector. Move the .safetensors file to the correct loras folder and refresh the file list.

Trigger word missing from the prompt

If you trained with captions that include a trigger word, that word must appear in your generation prompt for the LoRA to activate properly. Without the trigger word, the LoRA may appear to have no effect or produce inconsistent results. Add your exact trigger word at the beginning of the prompt.

LoRA strength set too low

A LoRA strength below 0.5 can produce results that look like the base model with no LoRA applied. Try increasing strength to 0.8-1.0 before concluding the LoRA has not trained correctly.

Model compatibility mismatch

LoRAs trained on Flux models must be used with Flux models. A LoRA trained on Flux cannot be loaded into a Stable Diffusion 1.5 or SDXL workflow — the architectures are incompatible. Confirm that the base model in your generation workflow matches the base model used during training.

Quick fix checklist: LoRA not showing up
• File location: Is your .safetensors file in the models/loras/ folder?
• Trigger word: Is your trigger word at the start of your generation prompt?
• Strength: Is the LoRA strength set to at least 0.7?
• Model match: Are you loading the LoRA into the same model type it was trained on?
• File refresh: Have you refreshed the LoRA file list after adding the file?

---

Frequently asked questions

How long does it take to train a LoRA model locally? +

Training time depends on your GPU, dataset size, and number of training steps. On an RTX 4090, training a 30-image dataset to 2,000 steps takes approximately 2.5-3 hours. On an RTX 3080, expect 4-5 hours for the same dataset. Lower-end GPUs (RTX 3060/4060 with 8GB VRAM) may take 6+ hours. Training runs in the background and does not require your active attention.

Can I train a LoRA offline with no internet connection? +

Yes. Once the base model files and training software are downloaded, all LoRA training runs entirely locally on your GPU with no internet connection required. No prompts, images, or model data are sent to any server. This is one of the key advantages of local training over cloud-based fine-tuning services.

How many images do I need to train a LoRA? +

The minimum effective dataset for a LoRA is approximately 15-20 images. Below this, the model typically under-trains and produces inconsistent results. The optimal range is 25-50 images — varied in angle, lighting, and composition but consistent in subject. Above 80 images, you often see diminishing returns unless the dataset is highly diverse.

What is the difference between training on Flux vs Stable Diffusion 1.5? +

Flux is a newer, higher-quality architecture that produces more photorealistic outputs and better follows complex prompts. Flux LoRAs require more VRAM (minimum 12GB recommended) and longer training times. Stable Diffusion 1.5 LoRAs can be trained on 6-8GB VRAM and train faster, but produce lower resolution and less photorealistic results. For new training projects, Flux is the recommended choice if your hardware supports it.

Why does my trained LoRA not look like my training images? +

The most common reasons a LoRA does not match its training data are: insufficient training steps (under-training), missing or incorrect trigger word in the prompt, LoRA strength set too low, or a dataset with too much variation between images. Start by increasing training steps to 2,500-3,000, ensuring your trigger word is in the prompt, and setting LoRA strength to 0.85-1.0.

Can I run LoRA training on a Mac? +

Yes. LoRA training on Apple Silicon (M1, M2, M3, M4) is supported using the MPS backend instead of CUDA. Training is significantly slower on Apple Silicon compared to a comparable NVIDIA GPU, but fully functional. Expect training times roughly 2-3x longer than an equivalent NVIDIA RTX card. Promptus supports Mac training with no additional configuration.

---

The bottom line: local LoRA training is worth the setup

Training a custom LoRA model locally gives you something no cloud service can provide: a model that belongs entirely to you, trained on your data, running on your hardware, with no ongoing cost and no restrictions on what you can train. The one-time investment in setup time pays off in unlimited generations from a model built for your exact use case.

The fastest way to get started is to download Promptus, which installs the complete local training environment in one step — models, nodes, and workflow all included. From there, the steps in this guide apply directly with no command line required.

Take complete ownership over your generative ecosystem. Build specialized patches privately, securely, and completely offline on your own machine.

Try Promptus Free →

Sources: Stable Diffusion Core Models Repository · Flux Architecture Specification · Local Infrastructure Framework Docs