Cover pic by SAN0

Introduction

Firstly, and I cannot stress this enough, I am not an expert. Some things I say in this article may be incorrect. However, I do hope I can help those looking to get into Anima training who are struggling to find beginner-friendly resources.

What I'll be doing here is walking through how I've been training LoRAs lately, not what I believe is the perfect solution for every use case. If you see anything in this article that you disagree with or believe I've gotten wrong, please let me know. I'm very open to criticism, and if your suggestion makes sense, I'll happily update the article.

One final thing before we begin: don't expect your first LoRA to be amazing. LoRA training has a learning curve, and almost everyone makes mistakes at the start. I trained several LoRAs before I made one I was genuinely happy with. That's completely normal, so don't get discouraged if your first few attempts aren't perfect.

Dataset

Attached to this guide is the dataset I used to train my Death from Puss in Boots character LoRA (it's all SFW, I promise). Feel free to use it as a reference while reading through this guide.

A good dataset will make or break your LoRA, and that's why I want to talk about it first. You can have the best trainer running the perfect settings on a 5090, but your LoRA will always be held back if your dataset is poor. The opposite is also true, if you have a good dataset, it becomes significantly harder to completely ruin your LoRA through training settings alone.

For that reason, I'll give a brief overview of the core principles here, then link a few articles that cover the topic in much greater detail.

Images

How many?
This is where things already get controversial.

My personal (and likely outdated) comfort goal is around 30 images for character LoRAs, 50 for style LoRAs, and 100 for concepts.

However, and I cannot stress this enough, don't worry about trying to reach a specific number. Other trainers have reported excellent character LoRAs trained on fewer than 10 images, while others have successfully trained LoRAs using datasets numbering in the thousands.

Larger datasets have some clear advantages. They generally provide more variety in poses, expressions, lighting, backgrounds and compositions, making it easier for your LoRA to learn the underlying concept instead of memorising a handful of images. They can also make your LoRA more flexible when prompted in ways that weren't present in the training data.

So if I had to answer the question of "How many images do I need?" in one sentence, it would be:

As many as you can, within reason.

Focus on quality before quantity. A smaller dataset full of excellent, varied images will almost always outperform a much larger dataset filled with duplicates or poor-quality images.

What images to use?
Focus on images that are easy to visually understand and clearly show the subject you're trying to train. You also want plenty of variety: different poses, expressions, clothing (where appropriate), backgrounds, camera angles, lighting, and compositions. Repeating the same kinds of images too often can make your LoRA overfit to those specific patterns.

Ask yourself these questions when choosing an image. If the answer to any of them is no, either edit or remove the image. A few poor images can have a surprisingly large impact, especially on smaller datasets.

• If my LoRA generated an image like this, would I be happy with the result?

• Is the subject clear and easy to understand, both for me and for an autotagger?

• Is the subject I'm trying to train the clear focus of the image, without unnecessary characters or distractions?

• Does this image add something new to my dataset, or is it just repeating another image's pose, expression, composition or camera angle?

• Can I clearly see the details I want my LoRA to learn?
  (For example, is the image sharp, high quality and free from heavy compression or motion blur?)

• Is there anything in this image that I don't want my LoRA to learn?
  (Such as watermarks, text, unwanted objects, or a background that appears too often.)

When selecting images, your focus should always be on quality, not quantity. Don't fall in love with individual images, and never hesitate to remove one if you think it's weakening your dataset.

Examples of Good and Bad images

Let's pretend I'm trying to make a character LoRA for this very handsome looking cheetah character below.

Examples of Good images
As we discussed earlier, a good dataset is about more than just clear images, it also needs variety. The collage below (thanks, ChatGPT!) shows the kinds of images I'd aim to include when training a character LoRA. Notice that the subject stays the same, while the poses, expressions, clothing, backgrounds, lighting and camera angles all change.

Examples of Bad Images
On the other hand, here are some examples of images I'd generally avoid. A single bad image won't necessarily ruin your LoRA, but several poor images can quickly add noise to your dataset. When in doubt, it's usually better to leave an image out than hope the trainer ignores it.

Tagging

Natural Language vs Danbooru vs e621?
This is another major topic where opinions seem to be divided.

My current belief is that you should tag your images in the same style that you like to prompt your LoRAs. If you use natural language prompts, use natural language captions. If you use Danbooru tags or e621 tags, use those instead. While there's still plenty of debate around which approach is best, matching your captions to your prompting style is a simple and practical place to start.

Personally, e621 tags are the most natural to me and also seem to be what most people who use my LoRAs prefer, so that's what I stick with. I like using RedRocket's Joint Tagger Pilot 3 with a threshold of 0.5. You can find the download and installation instructions below:

https://huggingface.co/RedRocket/JTP-3

Trigger Words
Once you've tagged your images, it's helpful to add a trigger word, something distinct that identifies your LoRA.

With Anima, it's generally recommended to prefix your trigger word with an @. So, for a style LoRA based on an artist named "artist", you could use @artist, or something like @artst if you're worried about it matching an existing token in Anima's training data.

I also recommend making your trigger word the first tag in every caption file. This becomes important later if you decide to shuffle your captions, as we can prevent that first tag from being moved.

I will note that I also do this for my character and concept LoRAs, although I'm still experimenting and I'm not yet convinced it's always the right approach.

Examples of Good and Bad Tagging

To explain the basics of tagging, let's use the image below as an example.

We'll pretend this is one image from our dataset and walk through how I would think about tagging it. Let's also assume the trigger word is @boerboer. There isn't a single "correct" caption, but there are definitely tags that are more useful than others.

Overtagging
One of the easiest mistakes to make is adding far more tags than your LoRA actually needs.

Remember that most people using your LoRA won't be writing huge prompts. If you're training this cheetah character, tags like mammal, animal, fur, tail or plantigrade usually aren't helping much. They're either obvious, already implied by more specific tags, or things the user probably isn't interested in controlling.

Every unnecessary tag gives your LoRA something else to learn, which can dilute the concepts that actually matter.

As a general rule, if removing a tag wouldn't meaningfully change how someone prompts your LoRA, you should at least question whether it belongs.

Undertagging
The opposite mistake is leaving out information that your users do want to control.

Looking at this image, if you only tagged it with something like @boerboer, solo, sitting, your LoRA would have to guess everything else. Because every image in your dataset might show the character wearing a blue t-shirt and beige shorts, it could start assuming those clothes are part of the character. The same goes for things like a smile, looking at the viewer, or sitting on a bench.

As a general rule, tag attributes that you want users to be able to change. Clothing, expressions, poses, accessories, hairstyles, and important objects are all usually worth including, even if they appear in most of your dataset.

A good rule of thumb is if you'd expect someone to type it into a prompt, it probably deserves a tag.

Good Tagging
Good tags strike a balance between the two.

They contain enough information for your LoRA to learn what matters, without overwhelming it with unnecessary detail.

For the example image above, I might use something along the lines of:

@boerboer, anthro, cheetah, male, sitting, bench, looking at viewer, smile, blue shirt, beige shorts, park, outdoors, daytime

This isn't the only correct answer, and your exact tags will depend on whether you're using natural language, Danbooru or e621 tags.

The important thing is that the tag describes the concepts you actually want your LoRA to learn, while leaving out details that don't add much value.

Hallucinated tags
Autotaggers are incredibly useful, but they aren't perfect. Occasionally they'll confidently assign tags for things that simply aren't in the image. This is known as a hallucinated tag.

For example, an autotagger might tag this image as necklace, wolf, or open mouth even though none of those are present. If left uncorrected across enough images, your LoRA may begin learning concepts that don't actually belong to your subject.

For that reason, never blindly trust an autotagger. Use it as a starting point, then quickly review the tags and remove any tags that are clearly incorrect. Spending a few extra seconds checking each tag can save you a lot of frustration later.

Managing tags
As your dataset grows, keeping captions consistent becomes surprisingly difficult.

For managing and bulk-editing tags, I personally like starik222's BooruDatasetTagManager. It makes it much easier to rename tags, remove unwanted ones, and keep your entire dataset consistent.

If you're ever unsure whether you're overtagging or undertagging, I also find ChatGPT surprisingly good at reviewing caption files and suggesting improvements.

You can find BooruDatasetTagManager, along with installation instructions, below:

https://github.com/starik222/BooruDatasetTagManager

Helpful links on dataset prep

Please comment articles and I'll add them to this list

https://civitai.red/articles/7483/civitais-trainer-a-simple-beginners-guide-to-training-character-lora-using-it

https://civitai.red/articles/91/how-to-correctly-obtain-images-for-a-dataset

Training Setup

Trainer Options

Before I mention what trainer I use, it's important to note that there are a variety of options out there. All have there strengths and weaknesses. The settings I'll list below can be applied to most of them and you'll likely still get great if not better results.

• Civitai Trainer - A great online solution if you can't or don't want to train locally. Uses ai-toolkit. Costs buzz to use and it's not as flexible as locally training, but it's very beginner friendly and frees up your PC.

• sd-scripts - Super powerful and performant but has no GUI. This is your bare bones, no hand-holding option. Not recommended for beginners, but if you're the type who likes to tinker under the hood, it might be a good option eventually.

• Kohya_ss, OneTrainer, and AI Toolkit - These are all excellent tools with large communities and plenty of advanced features. However, they're primarily designed for training other diffusion models and, at the time of writing, don't officially support Anima. However, beta/preview branches of these trainers have added Anima support, so they are working on it. These are also publicly available if you wish to use one of these trainers instead.
  

The Trainer I Use

I personally use gazingstars123's Anima-Standalone-Trainer. It's a GUI built specifically for Anima and uses the sd-scripts backend for the actual training. You can find the GitHub page, along with installation and setup instructions, below:

https://github.com/gazingstars123/Anima-Standalone-Trainer

Like everything else in this article, I can't promise it's the best solution available. It's simply the trainer that works well for me. It doesn't require manually editing TOML files, the interface is easy to understand, and it has a super handy built-in TensorBoard feature that we'll cover later.

Trainer Settings

This is the big one, and probably the most controversial section of the guide.

The philosophy behind these settings is simple: remove as much thought and guesswork from training as possible. Many of these settings can absolutely be adjusted and optimized, but I only recommend experimenting with them once you've taken the time to understand what they actually do.

For now, my goal is simply to give you a solid baseline that produces good results. If these settings let you train a LoRA you're happy with without wanting to throw your PC out the window, then I've done my job.

VRAM
Another term you'll see me mention throughout this guide is VRAM. Think of VRAM as the amount of memory your graphics card has available to work with.

I train on an RTX 3090 with 24GB of VRAM, so my settings naturally reflect having a bit more room to work with than most people. Throughout the screenshots, settings highlighted in blue are the ones you'll most likely want to keep an eye on and adjust if your graphics card has less VRAM.

Settings
Below are three screenshots showing the settings I used to train the Death LoRA and the dataset included with this guide.

Here I'm going to explain the reasoning behind some of my settings, and make suggestions where you might want to make edits. If you don't want to read all of that, though, feel free to simply copy these settings and adjust the blue ones according to the amount of VRAM your graphics card has, starting with the Batch Size setting first, as that will have the biggest impact.

Training section

• Learning Rate and Text Encoder LR
  "These two settings are where most of your thought and countless hours of research will go..." ...is what I would say if this wasn't a beginner's guide.

  Thankfully, we have the Prodigy optimizer to take most of the guesswork away. Prodigy manages the learning rate differently from traditional optimizers, so for this setup I simply set both of these values to 1 and forget about them for now.

• Optimizer
  This is the optimizer that determines how your LoRA learns.

  Prodigy is an adaptive optimizer, meaning it automatically adjusts the learning rate as your LoRA trains. This isn't magic, it can't fix a poor dataset or compensate for bad training settings, but it does remove a lot of the headache that traditionally comes with choosing learning rates.

• LR Scheduler
  The Cosine scheduler works hand in hand with the Prodigy optimizer to gradually reduce the learning rate over the course of training.

  Rather than using the same learning rate from start to finish, training begins with larger updates and gradually shifts towards smaller, more conservative ones. In simple terms, your early epochs learn quickly, while your later epochs focus on refining what they've already learned.

• Weight Decay
  Weight decay is a safety net that helps prevent your LoRA from overfitting your dataset.

  It works by gently discouraging the LoRA from making overly large changes during training. This encourages it to focus on learning the strongest and most consistent patterns in your dataset instead of memorising every tiny detail.

  A value of 0.1 is a very common and safe starting point. In general, higher values encourage your LoRA to generalize more, while lower values allow it to fit the dataset more aggressively. For beginners, I recommend sticking with 0.1.

• Max Epochs
  This is the part where many experienced trainers will probably tilt their heads at my choice.

  Yes, 200 epochs is intentionally far more than most LoRAs actually need, and that's the point.

  I'll explain my reasoning later, but for now, think of epochs like save files in a video game. The more save files you have, the more points you can go back to if needed. Later, you'll test a selection of these epochs and pick the one that gives you the results you like best.
  
  What's also worth noting is that if your dataset is large (maybe 200 or more images), then you might need a large epoch count than this. You can't really set it too high.

• Mixed Precision and Save Precision
  I recommend Googling which of the available precision modes your graphics card supports.

  I personally use BF16, as my RTX 3090 supports it and it offers excellent performance.

• DataLoader Workers
  This setting doesn't affect how your LoRA learns, it only affects how efficiently your PC feeds data to the GPU.

  Increasing the number of workers allows more images, captions and preprocessing tasks to be prepared in parallel. The ideal value depends on your CPU, RAM and storage speed. I use 8, as it's a safe value that doesn't add much overhead on my system.

• Gradient Checkpointing
  This setting can significantly reduce VRAM usage, but it comes at the cost of slower training.

  If you're close to your VRAM limit, I recommend leaving it enabled. If you have plenty of VRAM available and want slightly faster training, you can turn it off.

• Flash Attention
  If your graphics card supports Flash Attention and you can get it working, it can both reduce VRAM usage and speed up training.

  I haven't managed to get it working reliably yet, so it's still on my to-do list.

• Torch Compile
  Torch Compile can speed up LoRA training, although it also increases the startup time before training begins.

  Personally, I find the extra startup time to be more hassle than it's worth, so I leave it disabled.

• Cache Latents
  Normally, your VAE has to encode every training image before it can be used. Enabling Cache Latents stores those encoded images so they don't need to be processed again, which can improve training speed.

  I personally ran into VRAM issues when using this setting, so if you're already close to your VRAM limit, I'd recommend leaving it disabled.

Dataset section

• Resolution
  1024 is still my go-to resolution because it's a good balance between image quality, VRAM usage and training speed.

  Higher resolutions (such as 1536) allow your LoRA to learn finer details, but they come at a significant cost to both VRAM usage and training time. Unless you have a specific reason to increase the resolution, I think 1024 is a great starting point.

• Batch Size
  Arguably one of the most important settings for a variety of reasons.

  Batch size determines how many images are processed before your LoRA is updated. Larger batch sizes generally produce smoother and more stable training, but they also require significantly more VRAM.

  A batch size of 4 fits comfortably on my 24GB RTX 3090, so that's what I use most of the time. If you have a 12GB card, you'll likely need to drop that to 2, while 8GB cards may need to use a batch size of 1.

  If you're worried about missing out on the benefits of a larger batch size because of your VRAM, don't worry, the next setting can help.

  As a rough rule of thumb, I also try to avoid using a batch size that's more than about 10% of my dataset size. So if your dataset only contains 30 images, I'd generally stick to a batch size of 3 or lower.

• Gradient Accumulation
  This is the hero of lower VRAM graphics cards.

  Gradient accumulation effectively increases your effective batch size without requiring additional VRAM. For example, a batch size of 2 with a gradient accumulation of 4 behaves similarly to an effective batch size of 8.

  This isn't free, it does slow training down a little, but it's an excellent way to get many of the benefits of a larger batch size without needing a more powerful graphics card.

  Personally, I leave this at 1, as I'm already happy with my batch size of 4.

• Alpha Mask
  I leave this enabled because I often edit my training images by removing unwanted objects and replacing them with transparency.

  If you don't work with transparent images, you can safely leave this disabled.

• Min Bucket and Max Bucket Resolutions
  Your trainer automatically groups images of similar aspect ratios into different "buckets" before resizing them.

  These settings define the minimum and maximum bucket resolutions. If you're training at 1024, I wouldn't recommend changing them. If you decide to train at a higher resolution, you'll generally want to update these values to match.

• Image Directory
  This is simply the location of your dataset containing your images and caption (.txt) files.

  I recommend keeping both your dataset and your trainer on your fastest drive if possible, as it can slightly improve loading performance.

• Num Repeats
  This is another setting where I'm deliberately choosing simplicity over optimization.

  Num Repeats determines how many times each image is shown to the trainer before an epoch is saved. Increasing this value means each epoch contains more training, allowing you to use fewer epochs overall.

  There's absolutely nothing wrong with increasing this anywhere between 2 and 15, depending on your dataset size. It can reduce the total number of epochs you need and save a bit of disk space.

  However, it also introduces another variable to think about, and the whole philosophy of this guide is to remove as much guesswork as possible. That's why I simply leave it at 1. Hopefully the reason will become apparent later when we talk about epoch selection.

• Keep Tokens
  Arguably the worst-named setting in the trainer.

  This only matters if you're enabling Shuffle Captions, which I'll explain next.

  Keep Tokens prevents the first X tags in each caption from being shuffled. This matters because earlier tags generally carry slightly more emphasis during training.

  If you're using a trigger word, I recommend placing it as the first tag in every caption and setting Keep Tokens to 1 so it always stays there.

• Shuffle Captions
  Do not enable this if you're using natural language captions.

  This setting randomly shuffles the order of your tags each time an image is used during training. It helps prevent the model from placing too much importance on tags simply because they always appear near the beginning of the caption.

  If you're using tag-based captions (such as Danbooru or e621), I recommend leaving this enabled.

• Flip Augmentation
  Flip Augmentation creates a horizontally mirrored version of each training image during training.

  This is great for increasing dataset variety and can help prevent overfitting to specific poses, facial angles and compositions.

  However, don't enable it if you're training a character with important asymmetrical features, such as a single eyepatch, a distinctive hairstyle or markings that only appear on one side, or if your dataset contains lots of readable text or logos, as those will also be mirrored.

Network section

• Quick note on Network Dim and Network Alpha
  For some reason, this trainer seems to work best when Network Dim and Network Alpha are set to the same value. I'm honestly not sure whether that's a limitation of this trainer or something specific to Anima, but it's something to keep in mind if you're using this setup.

• Network Dim
  Network Dim determines the capacity of your LoRA, essentially how much room it has to learn.

  If you've ever wondered why some LoRAs are only a few megabytes while others are hundreds of megabytes, this setting is one of the biggest reasons why.

  A higher dim gives your LoRA more capacity to learn details, but bigger isn't always better. If the dim is too high, your LoRA may start learning details you don't actually want, such as backgrounds or other features that should remain flexible. On the other hand, if the dim is too low, your LoRA may simply not have enough capacity to learn everything it needs.

  As a rough starting point, my recommendations are:

  • 8 for simple concepts or character LoRAs with smaller datasets.

  • 16 for most use cases.

  • 32 for more complex concepts, multi-character LoRAs, or style LoRAs with very large datasets (approaching 1,000 images).

  These aren't hard rules, just a good starting point while you're learning.

• Network Alpha
  If Network Dim is the size of the notepad, Network Alpha is the size of the pen you're writing with.

  This is a fairly advanced concept that I don't fully understand myself, so rather than pretending otherwise, my recommendation for beginners is simple: keep it the same value as your Network Dim.

• Train UNet Only
  Unless you're an expert (and if you are, why are you reading this guide?), I recommend leaving this enabled.

  Training the text encoder changes how your LoRA represents and associates words. Unless you're trying to teach Anima completely new concepts or tokens, and you're very confident in your captions, I'd recommend sticking to training the UNet only.

• Auto-resume from last saved state
  This is a super handy feature that's worth leaving enabled.

  It allows you to stop your training at any point and continue from the last saved state later, which is especially useful if your LoRA takes multiple sessions to train.

Prompting section
I'm not including the Prompting section screenshot because I don't personally use it, so I don't feel comfortable recommending specific settings.

That's not to say it isn't useful, quite the opposite. Enabling it allows the trainer to generate sample images after each epoch, making it easy to see how your LoRA is progressing while it trains.

In fact, I'd actually recommend enabling it for your first few LoRAs. Watching the generated samples change over time is a great way to build an intuition for how training works.

If you do use it, here are a few prompts I'd recommend including:

• A complete caption taken directly from your dataset. This lets you see when your LoRA has successfully learned the images and trigger words from your training data.

• A prompt containing concepts that Anima struggles with out of the box. This makes it easier to judge how well your LoRA is learning those concepts over time.

• A prompt based on one of your dataset images, but without the trigger word. This can help you see how strongly your trigger word has been learned and how dependent the LoRA is on it.

As training progresses, also keep an eye out for signs of overtraining. Preview images may start looking overly saturated, overly sharp, or unnaturally stiff. If you notice this happening consistently, it's often worth testing some earlier epochs.

Personally, though, I leave sample generation disabled because generating preview images takes time that could otherwise be spent training. Instead, I simply test the epochs once training has finished.

Global settings

This is something that might not be immediately obvious. Before training can begin, the trainer needs to know which model, text encoder, and VAE your LoRA will be trained against.

I recommend using Anima Base 1.0, along with the same text encoder and VAE you normally use when generating images with Anima. This gives your LoRA the best chance of working well across different versions and finetunes of Anima.

If you're 100% certain you'll only ever use your LoRA with a specific Anima finetune, then feel free to use that model instead. Otherwise, I'd recommend sticking with the base model for maximum compatibility.

Training and Testing

Pre-Training Checks

How long does training take?
Here's the bad news: training takes a while.

Exactly how long depends on a wide range of factors, including your PC, your dataset size, your training settings, and ultimately how long you're willing to let it run.

In rare cases, training might only take around an hour. For me, most LoRAs take somewhere between 6–12 hours, while larger projects can easily take days.

When to train?
This might seem like a silly question, but it's worth planning when you're going to train.

Remember that your PC will likely be running close to full capacity for the entire training process, which means you probably won't be gaming or doing anything else that heavily relies on your graphics card.

Personally, I like starting my training either overnight or just before I head out for the day.

Thankfully, the trainer saves your progress as it goes, so if your LoRA takes longer than expected, you can simply continue it another day.

One last check
I cannot stress this enough, double-check everything before clicking that Train button.

It's heartbreaking to spend hours (or even days) training a LoRA, only to realise you accidentally typed 1 instead of 0.1, forgot to remove a bad image from your dataset, or made a mistake in your captions.

Take a few extra minutes to go over your settings and dataset one final time. It's almost always worth it.

Running and Monitoring Your Trainer

Starting your trainer
This is the moment of truth.

When you're ready, say a short prayer and click the Train button in the top-right corner.

You'll then be taken to the Console tab, where you'll be greeted with more text than any sane person is going to read. Don't worry, that's just the trainer preparing everything it needs before training can begin, and there are quite a few steps involved.

Because of this, it's completely normal for a few minutes to pass before the first training step actually starts.

If you run into an error (and, if this is your first time, there's a good chance you will), I recommend copying the error message from the console and pasting it into ChatGPT as a starting point for troubleshooting.

Be patient, you'll get there eventually. Running into setup issues is practically a rite of passage for everyone who starts training LoRAs.

Monitoring your progress
Once training has started, you'll see output similar to this updating over time:

steps: 37%|███▋ | 9204/25200 [05:15<29:09:59, 6.56s/it, avr_loss=0.0593]

The first thing to remember is that we intentionally set the maximum number of epochs much higher than we actually expect to use. That means the overall progress percentage and ETA aren't especially important, because they aren't what we'll use to decide when our LoRA is "finished."

Instead, I mainly keep an eye on two things:

• Steps completed

• s/it (seconds per iteration)

Your step count should steadily increase over time. If each step suddenly starts taking an unusually long time, something may be wrong.

Likewise, keep an eye on your s/it value. This simply tells you how many seconds each training iteration is taking. In general, lower is better. If you're consistently seeing values above 15–20 s/it, it may be worth looking at your settings to see if you can improve performance.

Just don't judge it immediately after training starts. it's completely normal for the first few minutes to be slower while everything warms up.

Monitoring your PC
Remember that your PC is working pretty hard during training.

I recommend opening whatever performance monitoring tool you normally use (Windows Task Manager works perfectly fine) and keeping an eye on your CPU, RAM and GPU usage. In particular, make sure you aren't running out of VRAM or system memory, as both can dramatically slow down training.

Tensorboard and Loss

What is TensorBoard?
This is the secret weapon I've been hinting at throughout the guide.

TensorBoard lets you monitor your LoRA's training as it happens, and it's the main reason we don't need to blindly wait for all 200 epochs to finish before deciding which epoch to use.

What is loss? (no, not the meme)
Before we dive into TensorBoard, it's important to understand what loss actually means, because everything else builds on this idea.

Loss is simply a measurement of how wrong your model's predictions currently are. A high loss means your LoRA still has a lot to learn, while a low loss means it's getting much closer to matching your training dataset.

A simple way to think about it is a game of darts. The lower your loss, the closer you're getting to the bullseye.

That doesn't necessarily mean lower is always better. The "best" epoch depends on both your dataset and what you're trying to achieve. However, for the sake of learning TensorBoard, we'll start with the simplified idea that lower loss is generally better, then refine that idea later when we begin testing epochs.

How do I launch TensorBoard?
To the right of the Console tab, you should see a TensorBoard tab.

Click it, then press Launch.

Keep in mind that TensorBoard can only be launched after your LoRA has completed at least one training step. If nothing appears after launching it, try refreshing your browser.

You can also launch TensorBoard at any point during or after training, even days later, as long as you haven't deleted your training logs.

Below is a screenshot of my Death LoRA's TensorBoard after a few hours of training. Don't be intimidated by all the squiggly lines, I'll explain the important ones in the next section.

• Loss/epoch_average
  This is the graph you should be paying attention to during training, and it's what we'll use to decide when it's time to stop.

  As your LoRA trains, you should see this graph trend downward in a similar pattern to the one above. What you're looking for is when the curve reaches what's commonly referred to as a loss floor. This is the point where the loss stops making meaningful progress and instead starts flattening out or bouncing around within a fairly small range. In simple terms, your LoRA has learned most of what it can from the dataset, and additional training usually provides diminishing returns.

  One important thing to remember is that you won't know you've reached the loss floor the moment it happens. It's only after another 10–20 epochs that it becomes obvious the curve has levelled out, so be patient and let the trainer continue for a little while.

  You can hover your mouse over the graph to see the exact loss value for each epoch. In the example above, my training reached its lowest loss at around epoch 179, so that became the first epoch I tested (and eventually published).

  However, the lowest-loss epoch isn't automatically the best LoRA. It simply matches your training dataset the most closely. Earlier epochs often generalize better, so I recommend picking the lowest-loss epoch along with several earlier checkpoints where the loss briefly dipped. Test all of them, you may find you actually prefer one of the earlier epochs.

• Learning rate
  In the bottom half of TensorBoard, you'll see the learning rate graphs.

  Because we're using the Prodigy optimizer together with the Cosine scheduler, your graphs should look fairly similar to mine. They'll start high and gradually decrease over time, allowing the LoRA to make larger updates early in training before switching to smaller, more conservative ones later.

  Unless these graphs look completely abnormal, I wouldn't spend too much time analysing them. They're mainly useful as a quick sanity check that your learning rate is behaving as expected.

Testing your Epochs

At this point, you should have your lowest-loss epoch, along with a handful of earlier epochs that also look promising.

Remember, one of these epochs may end up being downloaded and used by hundreds or even thousands of people. It's worth taking the time to properly compare them and choose the one that best matches your vision.

Fire up your image generator of choice and start testing.

Where can I find these epochs?
They should be in your trainer's directory, under training-ui\jobs\{job_name}\output. The number appended to the name of each file will tell you what epoch they match against. Use these files like any other LoRA you would download online.

How to test and pick an epoch
Testing has never been my strongest skill, but having a consistent testing process makes a huge difference.

A simple approach is to prepare 5–10 prompts and generate each one using every epoch you're testing. Keep the same seed between epochs so you're making a fair comparison instead of accidentally giving one checkpoint a luckier composition.

I also recommend not using detailers during testing, as they can hide imperfections that might otherwise help you distinguish between epochs.

Once you've generated everything, compare the results side by side. Look for the epoch that performs most consistently, rather than the one that happened to produce a single amazing image.

Try not to fall in love with any particular epoch before you've finished testing. Stay objective, gradually eliminate the weaker candidates, and keep comparing until you're reasonably confident you've found your favourite.

What sort of prompts should I test
This is something I see people get wrong quite often.

Try to avoid prompts that closely resemble images already in your dataset. Instead, test prompts that challenge your LoRA and ask it to do something new.

For example, with my Death LoRA, I'd test something like Death sitting on a beach, wearing shorts and drinking a milkshake, an image that's almost certainly not present in the training data.

Overtrained checkpoints often struggle with prompts like these, making them a great way to judge how well each epoch generalizes. If one epoch keeps trying to recreate your training images while another follows the prompt more naturally, that earlier checkpoint may actually be the better choice

Publish your epoch
Once you've settled on your favourite epoch, I recommend renaming the file to something a little more descriptive before publishing it.

And finally, pat yourself on the back. If you've made it this far without giving up, you've earned it.

Generate some great sample images, publish your LoRA, and hopefully you'll get the satisfaction of knowing that people out there are using something you created.

Final Thoughts, Tips and Thanks

• LoRA training is an incredibly difficult process. If it were easy, everyone would be doing it. I can almost guarantee you that you will not be happy with the first LoRA you create. Don't be discouraged, it's normal and a part of the process. I trained at least 5 LoRAs before I got my first "good" one, then from there things started clicking.

• Don't be scared to ask people for help. If you're having issues, feel free to comment down below and I'll help if I have time (and knowledge of the solution). Also there is a large community of trainers out there. The Civitai Discord has a training help section that is still active (and filled with people smarter than me). Also the Furry Diffusion Discord is often happy to help if you're into that side of things.

• Here's a super useful tool that lets you inspect LoRAs to get some more info on how they were trained. You can try using in on other people's LoRAs to get some insight on how your favourite LoRAs were made. https://lora-inspector.rocker.boo/

• Don't delete your datasets after you've trained your LoRA. They might come in handy again if you decide to make a V2 of your LoRA and you'll be thankful that you don't have to start from scratch.

• Don't be discouraged if you're testing your LoRA and you aren't immediately getting good images. Sometimes it requires a different prompt, weight or checkpoint to bring out its potential. Maybe lower the weight to 0.8 and see what it does, or try a different checkpoint.

• Massive thanks to Murf_ for helping me put together this article. A lot of what I know about Anima training comes from him. Do check his models out.

• Another massive thanks to Vennin who was instrumental in helping me first get into Anima training. Check out there Anima Furry Domain LoRA, it's really good.

• Yet another massive thanks to sxus_Sw for also providing help and feedback on Anima training. A big reason I got into LoRAs was thanks to their articles on Illustrious training.

• Thanks again to SAN0 for allowing me to use their pic for the cover.