Training a MOSS-Image Character LoRA at 1024px with ROCm on EVO-X2
Contents

I trained a character LoRA for MOSS-Image Base at 1024px resolution under ROCm on a GMKtec EVO-X2 (Ryzen AI Max+ 395 with Radeon 8060S).
LoRA (Low-Rank Adaptation) trains lightweight adapter weights rather than modifying the base model itself. Using a 70-image dataset originally prepared for Anima, I rewritten the captions for MOSS-Image and ran the training up to 3,000 steps (model weight updates) using ai-toolkit. This log records step timings, GPU memory behavior, progressive output changes, prompt adjustments for body proportions and color tone, and tests applying the resulting LoRA to an anime-oriented derivative checkpoint.
Environment and Prerequisites
Training ran on a GMKtec EVO-X2 equipped with an AMD Ryzen AI Max+ 395, an integrated Radeon 8060S GPU (gfx1151), and 64GB of unified memory shared between CPU and GPU. GTT (Graphics Translation Table) represents the system memory mapped and accessible to the GPU.
| Item | Details |
|---|---|
| OS | Ubuntu 26.04.1 LTS, Kernel 7.0.0-43-generic |
| GPU Available Memory | GTT 56GiB (mem_info_gtt_total at 60129542144), expanded via kernel argument ttm.pages_limit=14680064 |
| PyTorch | 2.12.0a0+rocm7.13.0a20260411 (AMD development build for gfx1151) |
| Training Toolkit | ostris/ai-toolkit commit d6a18ad (November 13, 2026), Python 3.12 |
| Base Model | MOSS-Image Base bf16 (unquantized foundational weights) |
| Text Encoder | Qwen3.5-9B bf16 (unloaded after caching embeddings) |
| VAE | FLUX.2 VAE |
Prior to training, no other GPU-intensive processes such as llama-server or ComfyUI were active. Available system memory stood at 55GB.
Environment setup and baseline execution had been validated in earlier prep runs. Measurements from that smoke test (using 9 non-character test images) are shown below:
| Resolution | 1 Step | Total Time (including loading and caching) | Peak RSS |
|---|---|---|---|
| 512px | 4.4 s | 2m 26s for 12 steps | 28.0GB |
| 1024px | 34.4 s | 6m 35s for 6 steps | 26.8GB |
At 1024px, 2,000 steps project to roughly 19.1 hours (34.4 s × 2000).
While the preliminary smoke test suggested 512px, the training images were all at least 1024px, so I opted for 1024px.
It remained unverified whether character LoRA training would successfully complete and produce usable weights on this APU setup. I focused on a single character, “Kana”.
MOSS-Image Training Caption Specifications
The training images were adapted from a 4-character merged dataset originally built for Anima. Because those captions were tailored for Anima, they required conversion for MOSS-Image.
Key points gathered from the official user guide (commit 6be4453, November 8, 2026):
| Topic | Official Guidance |
|---|---|
| Input Format | Accepts natural language, tag lists, and JSON layout structures |
| Language | English recommended due to training data volume |
| Tag Ordering | Quality → Score → Meta → Year → Character → Series → Artist → General |
| Fine-tuning | Text encoder should remain frozen |
| Caption Generation | Use a VLM to generate long, medium, and short JSON captions; long captions detail composition, primary subject, action, setting, color, lighting, and art style |
| In-image Text | Write exactly as seen without translation or romanization |
| Watermarks | Do not mention in captions; record in a separate metadata field |
| Recommended VLM | Gemma 4, Qwen 3.5 27B, Qwen 3.5 35B-A3B |
The official guide does not specify trigger word conventions or whether invariant character traits should be omitted in captions. For that, I consulted three external guides:
| Source | Caption Advice |
|---|---|
| airmore.ai | Recommends detailed natural language. Place the trigger word at the beginning. Warns that repeating invariant features (hair, outfit, background) across all captions can cause unwanted associations |
| imagelora.dev | Works with plain natural language. Describe elements you want to vary later; omit traits you want baked into the LoRA |
| note.com ai-toolkit guide | Place a .txt file with the same base name alongside each image. Use a single coined trigger word. Does not mandate natural text versus tags |
Looking at ai-toolkit’s MOSS-Image implementation (extensions_built_in/diffusion_models/moss_image/moss_image.py), captions are formatted through Qwen3.5-9B’s chat template before embedding, with a 4,096-token ceiling. Truncation is unlikely even with long natural text.
Extracting and Converting Images and Captions
The source pool was merged-4char-dataset (518 images total). Filtering for solo images with filenames starting with kana_ yielded 75 images (63 kana_NNNN and 12 kana_addNN). Multi-character pairings were excluded.
Of these 75, 5 images lacking a safe rating tag (4 sensitive, 1 explicit) were removed, leaving 70 images.
A representative source caption looked like this:
masterpiece, best quality, score_7, safe, 1girl, solo, kanachan, A close-up portrait of a young girl with an angry expression and a slight frown looking directly at the viewer. Her side ponytail with a blue scrunchie is visible on the right side of the image, and a small antenna of hair rises from the top of her head. side ponytail, ahoge, double parted bangs, medium hair, blue scrunchie, angry, frown, looking at viewer, portrait, bare shoulders, white background, simple background
Prefix quality/rating tags were followed by 1girl, solo and the trigger word kanachan, then a natural language description, and finally a Danbooru tag sequence.
This was restructured as follows:
| Source Caption Component | Handling for MOSS |
|---|---|
masterpiece, best quality, score_7, safe | Removed. These are Anima quality/score conventions, and whether they transfer to MOSS-Image was untested |
1girl, solo | Removed |
Trigger word kanachan | Integrated into the subject of the sentence, replacing a young girl with a girl named kanachan |
| Natural language body | Retained intact, including descriptions of which side the ponytail appears on |
| Trailing Danbooru tags | Removed, eliminating duplicate tags for hair style, hair color, and eye color |
| Background | When only present in tags, appended Anime-style illustration with a plain white background. |
The converted result:
A close-up portrait of a girl named kanachan with an angry expression and a slight frown looking directly at the viewer. Her side ponytail with a blue scrunchie is visible on the right side of the image, and a small antenna of hair rises from the top of her head. Anime-style illustration with a plain white background.
Guides differ on whether to strip all invariant traits. Here, hair and eye color tags were dropped, but the spatial orientation sentence for the side ponytail was kept.
Kana’s side ponytail sits on the right side when viewed from the front (and on the left from behind). In Anima training, preventing left-right flips was a key tracking item. Keeping this positional description fits the rule of describing variable details.
For 6 images where background color was unspecified in tags (only labeled simple background), colors were assigned manually by inspection (1 beige, 5 cream).
For the 12 kana_addNN images that were originally tag-heavy, natural sentences were constructed strictly from the existing tags and captions without inventing new visual details.
The resulting captions ranged from 31 to 71 words, averaging 48.3 words.
The conversion script was saved at ~/train/build_kana_moss_dataset.py, outputting to ~/train/datasets/kana_moss_v1/ (70 PNGs and 70 TXT files), with mappings logged in ~/train/kana_moss_v1_captions.jsonl.
Aspect ratios across the 70 images:
| Height / Width | Count |
|---|---|
| 1.0 | 48 |
| 1.38–1.39 | 7 |
| 1.49–1.5 | 10 |
| 1.78–1.81 | 2 |
| 2.0 | 3 |
Several images feature a subtle star-shaped watermark in the lower-right corner. In accordance with official guidelines, these were not mentioned in captions.
Preliminary Test on Tall Aspect Ratios
An issue report for gfx1151 PyTorch ROCm noted potential failures when handling extreme aspect ratios in bf16 (ROCm issue #6034, noted in prior handover logs).
To guard against crashes 10 hours into training, the 5 images with height/width ≥ 1.78 were isolated for a 5-step test at 1024px.
| Metric | Result |
|---|---|
| Buckets | 720x1456 (3 images), 752x1392 (1 image), 768x1360 (1 image) |
| Step Time | Average 36.0 s (range 34.8–37.8 s) |
| Loss | 0.073, 0.222, 0.478, 0.078, 0.081 (no NaNs) |
| Total Time | 10m 30s (including loading and caching) |
| Peak Memory (RSS) | 27.06GB |
| Exit Code | 0 |
While a 5-step run cannot rule out long-term instability, it confirmed basic compatibility.
Full Training at 1024px for 2,000 Steps
Configuration followed the established baseline, updating only dataset path and target resolution.
| Parameter | Value |
|---|---|
| Resolution | 1024 (with aspect ratio bucketing) |
| LoRA Rank / Alpha | rank 16, alpha 16 |
| Optimizer | AdamW (standard 32-bit), learning rate 1e-4 |
| Batch Size | 1, gradient accumulation 1 |
| Steps | 2,000 (~28.6 epochs across 70 images) |
| Checkpoint Saving | Every 250 steps, saved in bf16 |
| Caption Dropout | 0.05 |
| Timestep Sampling | Default (sigmoid in ai-toolkit) |
| Gradient Checkpointing | Enabled |
| Quantization | None (both DiT and text encoder in unquantized precision) |
| Training Sample Generation | Disabled |
ai-toolkit generated 8 aspect ratio buckets:
| Bucket | Image Count |
|---|---|
| 1024x1024 | 45 |
| 832x1248 | 10 |
| 864x1200 | 7 |
| 720x1456 | 3 |
| 880x880 | 2 |
| 928x944 | 1 |
| 752x1392 | 1 |
| 768x1360 | 1 |
Training launched at 03:22:47 JST on November 15, 2026. Model loading, text embedding caching, and latent caching took approximately 9 minutes, with step 1 beginning at 03:32.
The first step completed in 35.6 seconds, with ai-toolkit estimating 19 hours 46 minutes remaining.
Metrics were collected through two mechanisms: the top-level process ran under /usr/bin/time -v, and a background script logged step count, loss, RSS, GTT/VRAM usage, GPU utilization, available RAM, swap, temperature, and power to ~/train/kana_moss_v1_metrics.jsonl every 60 seconds.
Metrics at Step 250
Checkpoint 250 (74MB) was written at 05:56 JST, 2 hours 24 minutes after step 1. Summarizing 145 metric snapshots:
| Metric | Measured Value |
|---|---|
| Average Step Time | 34.7 s (elapsed time from step 1 to 250 divided by 249) |
| Bucket Variance | ~35 s for 1024x1024, ~21 s for 880x880 |
| Process RSS | Recorded constant at 12.68GB (this captured the DataLoader worker rather than main process, corrected later) |
| GTT Memory | Min 17.1GB, Mean 35.3GB, Max 40.9GB |
| Available RAM | Min 3.7GB |
| Swap Usage | 1.19–1.25GB (virtually unchanged from idle) |
| GPU Utilization | Average 99.9% |
| GPU Temperature | 63–71°C, average 66.7°C |
| GPU Power | Average 85.1W |
| Loss (60s samples) | First half 0.330, second half 0.314 |
Loss values exhibited wide step-to-step fluctuations (0.07 to 0.8), with no pronounced decline at this stage.
GTT memory climbed substantially higher than in the 6-step smoke test (which peaked at 25.4GB). GTT expanded in discrete increments of roughly 6.8GB:
| Time | Step | GTT Usage | Available RAM |
|---|---|---|---|
| 03:32 | 1 | 17.1GB | 27.6GB |
| 03:40 | 15 | 27.3GB | 17.5GB |
| 04:12 | 70 | 34.1GB | 10.4GB |
| 04:52 | 140 | 40.9GB | 3.7GB |
| 05:57 | 250 (post-save) | 21.4GB | 22.7GB |
Following the checkpoint save at step 250, GTT usage dropped back to 21.4GB.
The step-wise expansion is presumed to occur as new image resolutions trigger fresh GPU buffer allocations across the 8 buckets.
Because another tier would exhaust available system RAM, memory and swap were closely monitored.
Memory Trajectory at Step 500
Checkpoint 500 was reached at 08:20 JST (4 hours 47 minutes from step 1).
GTT memory repeated the exact same stair-step pattern:
| Time | Step | GTT Usage | Available RAM |
|---|---|---|---|
| 05:57 | 250 (post-save) | 21.4GB | 22.7GB |
| 05:58 | 253 | 28.2GB | 16.2GB |
| 06:02 | 259 | 34.9GB | 9.9GB |
| 06:07 | 268 | 41.7GB | 3.2GB |
| 08:20 | 500 (post-save) | 17.7GB | 26.0GB |
After reaching 41.7GB at step 268, usage remained flat for 2 hours 13 minutes until step 500 without climbing to a fourth tier. GTT consistently reset on save, stepped up 3 tiers, and plateaued around 41–42GB.
Swap increased slightly from 1.19GB to 1.48GB. Minimum available RAM hovered at 3.2GB, running near capacity on this 64GB machine.
Output Check at Step 750 and Changing Save Intervals
Saving every 250 steps is coarse; if the optimal character convergence occurs between saves, the ideal checkpoint could be missed. Furthermore, with sample generation disabled, intermediate output quality had not been verified.
Because ai-toolkit cannot alter save intervals mid-run, I stopped training immediately after checkpoint 750 (10:44 JST), generated visual samples while GPU memory was free, and resumed with save_every: 100.
Process Management Pitfall
When issuing kill by PID, the targeted PID belonged to a DataLoader worker process sharing identical command-line arguments (which pgrep -f returned as the last match).
Terminating the worker caused the parent to halt with RuntimeError: DataLoader worker (pid 143483) is killed by signal: Terminated., cleanly stopping training at step 752. Two uncheckpointed steps were discarded.
This also clarified why earlier metrics showed a static RSS of 12.68GB—the script had been sampling the worker process. The true overall memory footprint from /usr/bin/time -v:
| Metric | Value (launch to termination past step 750) |
|---|---|
| Elapsed Time | 7h 22m 26s |
| Peak RSS | 27.53GB |
| User CPU Time | 52,332 s |
The metrics script was updated to select the process with maximum RSS among matching candidates.
Visual Samples at Steps 250, 500, and 750
Test generations ran on stable-diffusion.cpp (master-b521db4, Vulkan backend). Weights trained on MOSS-Image Base were loaded onto MOSS-Image SFT (the supervised fine-tuned variant) alongside the 4-step distillation LoRA (moss_image_sft_4step_v2.0), both set to strength 1.0. Settings: Euler sampler, 4 steps (here meaning 4 denoising iterations during inference), CFG 1.0, seed 42 fixed.
Logs confirmed 504/504 tensors applied for the trained LoRA and 756/756 tensors for the 4-step LoRA.
Generation averaged 53–56 seconds per image, including model loading overhead.
Three prompts aligned with the training caption style were tested:
| ID | Prompt | Resolution |
|---|---|---|
| p1 | A full-body front view of a girl named kanachan standing and facing the viewer directly, wearing a white collared shirt with red necktie, navy blue pleated skirt, black pantyhose, and brown loafers. Anime-style illustration with a plain white background. | 832x1248 |
| p2 | A close-up portrait of a girl named kanachan with a gentle closed-mouth smile looking warmly at the viewer. Anime-style illustration with a plain white background. | 1024x1024 |
| p3 | A girl named kanachan sitting on a park bench eating an ice cream cone, wearing a yellow sundress and a straw hat, smiling. A sunny park with green trees in the background. Anime-style illustration. | 1024x1024 |
p1 and p2 reflect compositions present in the training set; p3 tests unseen attire and environment. Hair style and color were omitted from all prompts.
Key visual traits for Kana include brown hair, a right-side ponytail, a blue scrunchie, and an ahoge antenna hair. Evaluating each checkpoint:
| LoRA | p1 (Full Body Uniform) | p2 (Portrait) | p3 (Park) |
|---|---|---|---|
| None | Near-black bob; no ponytail or ahoge | Black semi-long hair with floral ornament | Dark brown long hair |
| Step 250 | Shifted toward brown; still a bob | Brownish bob | Virtually identical to unadapted baseline |
| Step 500 | Lighter brown hair; shoulder-length straight | Braid and flower ornament on right side; not a ponytail | Lighter brown; remains long |
| Step 750 | Side ponytail and ahoge emerged | Side ponytail and blue scrunchie emerged; ahoge cropped at frame edge | Color matches; long hair persists without ponytail |
No LoRA (p1):

Step 250 (p1):

Step 500 (p1):

Step 750 (p1):

No LoRA (p2):

Step 250 (p2):

Step 500 (p2):

Step 750 (p2):

No LoRA (p3):

Step 250 (p3):

Step 500 (p3):

Step 750 (p3):

At step 750 (~10.7 epochs), recognizable hairstyle features began appearing in familiar compositions, though they had not generalized to novel scenes like p3.
With single seeds and samples, variance cannot be fully isolated, but these 12 images confirmed that Base-trained LoRA weights function properly atop SFT and the 4-step distillation LoRA.
Resuming with 100-Step Saves
I modified save_every from 250 to 100 and max_step_saves_to_keep from 12 to 40, keeping steps: 2000.
ai-toolkit picked up the latest checkpoint files (step 750 LoRA and optimizer.pt), resuming progress from 750/2000:
| Metric | Result |
|---|---|
| Downtime | 10:45:13 to 10:56:56 JST (~12 minutes) |
| Warmup to First Step | ~2 minutes (cached latents and text embeddings remained valid) |
| Subsequent Step Time | 34.3–36.4 s |
Subsequent saves were scheduled at 800, 900, and every 100 steps through 2,000.
Memory Exhaustion and Disabling DataLoader Workers
Immediately after resuming from step 750, GTT usage broke past its prior ~41GB ceiling into a fifth tier:
| Time | Step | GTT Usage | Available RAM | Swap Usage |
|---|---|---|---|---|
| 10:58 | 750 | 20.6GB | 26.9GB | 1.35GB |
| 10:59 | 752 | 27.5GB | 20.2GB | 1.36GB |
| 11:00 | 754 | 34.2GB | 13.7GB | 1.37GB |
| 11:05 | 763 | 41.0GB | 6.9GB | 1.37GB |
| 11:08 | 767 | 47.7GB | 1.0GB | 1.95GB |
| 11:09 | 769 | 54.4GB | 0.8GB | 8.30GB |
| 11:10 | 770 | 20.8GB | 33.9GB | 8.38GB |
At 11:09, GTT reached 54.4GB, available memory dropped to 0.8GB, and swap was almost entirely filled at 8.3GB. Exactly one minute later, GTT plummeted to 20.8GB and training continued without crashing.
Inspecting processes when memory fell below 1GB revealed two DataLoader worker processes idling with 10.6GB RSS each (0s CPU time), while the main training process consumed 2.0GB RSS.
GTT (47.7GB) + main process (2.0GB) + workers (10.6GB) accounted for ~60.3GB, matching system utilization. The workers appeared to retain duplicate memory from when the text encoder was initially loaded prior to fork.
Because latents and text embeddings were already cached on disk and batch size was 1, multi-worker loading offered no performance advantage.
After checkpoint 800 saved at 11:27, I stopped training and added num_workers: 0 (default was 2).
| Metric | 2 Workers (Default) | 0 Workers |
|---|---|---|
| Active Processes | Main + two 10.6GB RSS workers | Main only (RSS 2.6GB) |
| Available RAM at ~27.5GB GTT | 17.5–20.2GB | 30.0GB |
| Step Duration | ~35 s | 34.6–34.9 s |
Available memory increased by ~10GB with zero impact on step duration. Training resumed from 800/2000 after a 2-minute pause.
Earlier measurements attributing ~27GB peak RSS to the main process were taken while the text encoder was in memory; active training RSS is only 2.0–2.6GB. Real memory pressure came from GTT and duplicate worker allocations.
GTT Still Climbed, but Training Remained Stable
Monitoring memory after resuming with 0 workers:
| Time | Step | GTT Usage | Available RAM | Event |
|---|---|---|---|---|
| 11:31 | 803 | 27.8GB | 30.7GB | Post-resume |
| 12:01 | ~855 | 48.2GB | 10.8GB | |
| 12:28 | ~900 | 20.9GB | 37.5GB | Immediately after save 900 |
| 12:46 | ~932 | 54.5GB | 4.3GB | |
| 12:56:32 | 951 | 57.9GB | 1.0GB | No save triggered |
| 12:56:45 | 951 | 20.6GB | 37.7GB | Spontaneous reset without save |
At 12:56, available memory briefly dipped to 1.0GB before GTT dropped back to 20.6GB within 13 seconds, and training proceeded smoothly. Swap only rose from 1.9GB to 2.7GB. This spontaneous reset mirrored the behavior seen at 11:09.
Memory is reclaimed not only on checkpoint saves, but also dynamically when system memory nears exhaustion.
PyTorch Cached Memory Allocation
Reviewing ai-toolkit source code, checkpoint saves (save() in jobs/process/BaseSDTrainProcess.py) call flush(), which invokes torch.cuda.empty_cache().
empty_cache() releases cached, unallocated blocks retained by PyTorch’s caching allocator rather than active computational tensors. The memory accumulation was primarily retained cache blocks.
The spontaneous resets at 11:09 and 12:56 align with PyTorch freeing cached blocks upon allocation retries. As different aspect ratio buckets arrive, varying tensor dimensions likely demand new block sizes that prevent immediate reuse of earlier cached blocks.
Verification with Turbo LoRA
Midway through training, checkpoint 1300 was transferred to another machine and tested alongside a Turbo LoRA. Output generated successfully, though character identity remained loosely established at step 1300.
Coupled with the EVO-X2 tests using the 4-step distillation LoRA, both evaluations confirmed that Base-trained weights apply cleanly across low-step distilled pipelines.
Training Results up to 2,000 Steps
Step 2,000 completed at 23:02 JST on November 15, 2026, with exit code 0.
| Metric | Value |
|---|---|
| Total Duration | 03:23 to 23:02 (~19h 40m, including stops and intermediate tests) |
| Active Runtime Steps 1–752 | 7h 22m 26s |
| Active Runtime Steps 800–2000 | 11h 33m 22s |
| Step Duration | 33.9–35.2 s average across 50-step blocks (38.5 s during step 951 reset) |
| Checkpoints | Steps 250, 500, 750, 800–1900 (every 100), and 2000 (74MB each) |
| Active Training RSS (steps 800+) | Peak 2.6GB |
| Peak Process RSS (including setup) | 16.1GB |
| GTT Usage (steps 800+) | 17.5–57.9GB, average 37.3GB |
| Minimum Available RAM | 1.0GB (step 951) |
| Peak Swap Usage (steps 800+) | 2.8GB |
| GPU Telemetry | 99.9% utilization, 66.4°C average, 85.1W average |
Step duration remained constant across the entire run.
GTT peaks and available memory troughs across 100-step windows:
| Window | Max GTT | Min Available RAM |
|---|---|---|
| 800–900 | 48.2GB | 10.7GB |
| 900–1000 | 57.9GB | 1.0GB |
| 1000–1100 | 34.5GB | 24.4GB |
| 1100–1200 | 41.5GB | 17.4GB |
| 1200–1300 | 42.0GB | 16.8GB |
| 1300–1400 | 28.1GB | 30.4GB |
| 1400–1500 | 54.7GB | 4.3GB |
| 1500–1600 | 48.0GB | 10.9GB |
| 1600–1700 | 54.9GB | 4.2GB |
| 1700–1800 | 41.5GB | 17.3GB |
| 1800–1900 | 34.8GB | 23.9GB |
| 1900–2000 | 41.5GB | 17.5GB |
Loss medians grouped by 250 steps:
| Window | Mean Loss | Median Loss |
|---|---|---|
| 1–249 | 0.304 | 0.256 |
| 250–499 | 0.281 | 0.239 |
| 500–749 | 0.290 | 0.238 |
| 750–999 | 0.298 | 0.235 |
| 1000–1249 | 0.280 | 0.219 |
| 1250–1499 | 0.280 | 0.221 |
| 1500–1749 | 0.264 | 0.213 |
| 1750–1999 | 0.281 | 0.213 |
Median loss drifted downward gradually, plateauing after step 1,500.
Checkpoint Comparisons Across Steps 800–2,000
Generations across all 13 checkpoints between 800 and 2,000 using the same three test prompts:
Comparison sheet for p1 (full body uniform):

Comparison sheet for p2 (portrait):

Comparison sheet for p3 (park scene):

| Prompt | Observations |
|---|---|
| p1 (Uniform) | Side ponytail, ahoge, and brown hair stabilized from step 750 through 2,000. Negligible difference after step 800 |
| p2 (Portrait) | Side ponytail and blue scrunchie remained locked from step 750 onwards. Clothing varied (white t-shirt, sailor collar, collared shirt) since it was unprompted |
| p3 (Park) | Hair color changed to brown, but hair remained long and loose through step 2,000 without forming a ponytail |
Individual images at steps 1000, 1300, 1600, and 2000:

Character Fidelity and Prompt Phrasing
While intermediate checkpoints appeared consistent, a direct comparison against ground-truth training images revealed noticeable dissimilarity. Relying merely on the presence of a side ponytail and brown hair had masked facial divergence.
| Feature | Ground Truth Training Images | Step 2,000 Sample |
|---|---|---|
| Ahoge | Prominent curl | Absent or minimal in portraits |
| Eyes | Olive-brown with bold upper eyelashes | Generic anime brown eyes |
| Line Art & Shading | Heavy line weights, flat cel shading | Thinner outlines, heavier scene shading |
By contrast, the test run of checkpoint 1300 on the second PC exhibited strong facial fidelity, including eye shape and the distinct curved ahoge. The difference stemmed from prompt formulation:
Prompt used on the second machine:
kanachan — brown shoulder-length hair, short side ponytail tied with a blue scrunchie, ahoge antenna hair, full body, tank top and shorts, park bench, cheerful
The initial test prompt merely stated a girl named kanachan, omitting hair descriptions.
In the training set, 49 of 70 captions explicitly described the ponytail (Her side ponytail with a blue scrunchie...), and 6 described the ahoge. Because these descriptions were retained from Anima captions, hairstyle features became strongly conditioned on descriptive text rather than purely on the name trigger.
Verifying the Detailed Prompt on EVO-X2
Running the same prompt on EVO-X2 (seed 42, 1024x1024):
| Setup | Result |
|---|---|
| Without LoRA | Ponytail and scrunchie appeared, but on an unrelated dark-haired character with a thin ahoge |
| Step 1300 | Brown hair, large ahoge, blue scrunchie ponytail, closely matching the second machine’s output |
| Step 2000 | Preserved the same features with an open-eyed expression even closer to training ground truth |

The generator setup on this machine had not been at fault.
Testing Name-Only versus Explicit Hairstyle Prompts
Testing an unseen cafe setting with the step 2,000 LoRA:
| Condition | Result |
|---|---|
| Name only (weight 1.0) | Unrelated character with long hair |
| Hairstyle text included (weight 1.0) | Side ponytail, scrunchie, and ahoge emerged; shading slightly heavy |
| Hairstyle text included (weight 1.5) | Flatter shading, larger ahoge |
| Hairstyle text included (weight 2.0) | Visual blur and breakdown |

This LoRA cannot evoke the full character design from name alone; explicitly describing the hairstyle unlocks generation in novel scenes.
Testing Detailed Prompts for Character and Style
With short tag prompts, undescribed elements default to the base model’s intrinsic biases.
mage.space’s MOSS-Image prompting guide recommends specifying subject, action, setting, composition, art technique, lighting, and palette within a unified paragraph, maintaining a fixed character descriptor across scenes.
Adopting this structure, I constructed fixed descriptors for character and art style, varying only the scene description:
Fixed Character Block:
kanachan, a teenage girl with a slender build and natural proportions, about six and a half heads tall. She has shoulder-length light chestnut-brown hair with slightly messy outward-flipping ends and bangs falling between her eyes, a short side ponytail tied high on the right side of the image with a blue scrunchie, and one large curled ahoge standing up from the top of her head. She has large olive-brown eyes with thick dark upper lashes, a small nose, and a light blush on her cheeks.
Fixed Art Style Block:
Flat-colored anime illustration like a TV anime character design sheet, with clean bold dark outlines, simple cel shading with almost no gradients, and soft even lighting.
Scene blocks explicitly stated composition, eye-level framing, attire, pose, and background lighting:
| Scene | Size | Seeds | Result |
|---|---|---|---|
| Full body uniform, white background | 832x1248 | 42, 43, 44 | Consistent character identity across all 3 seeds; prominent ahoge, blue scrunchie ponytail, and brown hair |
| Park bench full body | 1024x1024 | 42, 43 | Consistent character identity with full-body framing; flatter shading, though stature appears slightly younger |
| Cafe upper body | 1024x1024 | 42, 43 | Consistent identity; heavy shading reduced |
| Portrait close-up | 1024x1024 | 42 | Clear ahoge and side ponytail |

Character consistency was solid across seeds and scenes. Three residual discrepancies remained:
- Head size was slightly larger and hair more voluminous than ground truth; bench scenes appeared younger despite specifying “six and a half heads tall”
- Hair color skewed slightly orange compared to ground truth, with eyes appearing warm amber-brown rather than olive-brown
- Line work was thinner than the training set
Full 50-Step Baseline Generation
To isolate whether the 4-step distillation LoRA was responsible, I generated the full-body uniform scene (seed 42) at 50 steps without distillation (MOSS-Image SFT + step 2000 LoRA, CFG 3.0, Euler, negative prompt worst quality, bad anatomy, watermark, jpeg artifact). This took 958 seconds (~16 minutes), compared to ~50 seconds with distillation:

Character appearance and composition were virtually identical to the 4-step output. Head volume and orange hair tint were equally present, proving neither was caused by the distillation LoRA.
Extending Training to 3,000 Steps and Adjusting Proportions and Colors
Because discrepancies in head-to-body ratio and hair color persisted regardless of distillation, I extended training from step 2,000 to 3,000 to observe whether further adaptation would align them.
Updating steps: 3000 in the config, training resumed from step 2,000 at 01:02 JST on November 16, 2026, finishing at 10:44 JST (9h 42m 49s runtime):
| Metric | Measured Value |
|---|---|
| Step Duration | 34.87 s average at completion |
| Peak GTT Usage | 54.9GB |
| Minimum Available RAM | 4.0GB |
| Peak Swap Usage | 2.4GB |
| Peak Process RSS | 15.6GB |
Median loss values across 250-step intervals remained flat (0.212, 0.221, 0.201, 0.206), mirroring the final bracket of the 2,000-step run (0.213).
Step 3,000 Visual Samples
Evaluated under identical prompts and seeds:

| Observation | Change from Step 2,000 to 3,000 |
|---|---|
| Identity Stability | High across all 3 seeds |
| Eye Color | Shifted from warm amber to a deeper brown, closer to ground truth |
| Hair Color | Remained slightly orange |
| Stature / Proportions | Unchanged; park bench scene remained youthful |
| 50-step Generation | Identical character and framing; slightly stronger orange saturation in hair |
Extending training by 1,000 steps improved eye color but left overall stature unaffected.
Steering Proportions via Prompting
To test whether stature was constrained by prompt phrasing rather than weights, I modified the age and body descriptions in two variations:
Option A:
kanachan, a 17-year-old high school girl who is tall and slender, with a small head, long legs, and the body proportions of an older teenager, about seven heads tall.
Option B:
kanachan, a young woman in her late teens with a slim, mature figure, a small head, narrow shoulders, a defined waist, and long legs, about seven heads tall.
| Variation | Full Body Uniform | Park Bench |
|---|---|---|
| Baseline | Slightly large head | Small stature, youthful |
| Option A | Smaller head, longer legs | Elongated torso and legs; face remained youthful |
| Option B | Proportions match Option A | Smaller head, mature frame; appeared oldest among the three |

Hairstyle, ahoge, and scrunchie rendered cleanly across all options. Body proportions were successfully steered through prompt text.
Calibrating Hair Color Saturation
Sampling RGB values from portrait crops downscaled to 200x200 and quantized to 8 colors:
| Image | RGB | Hue | Saturation | Brightness |
|---|---|---|---|---|
Ground Truth (kana_0001) | 190, 140, 111 | 22° | 0.42 | 0.75 |
Baseline Step 3000 (light chestnut-brown) | 191, 128, 93 | 21° | 0.51 | 0.75 |
Hue and brightness matched; the divergence was purely higher saturation.
Testing two prompt variations aimed at desaturation:
Option H1:
soft, muted light brown hair with a dusty beige tint, low in saturation and not orange or reddish,
Option H2:
pale milk-tea brown hair, colored #BE8C6F in the lit areas and #AB7B5F in the shaded areas,
| Phrasing | RGB | Hue | Saturation | Brightness |
|---|---|---|---|---|
| Ground Truth | 190, 140, 111 | 22° | 0.42 | 0.75 |
| Baseline | 191, 128, 93 | 21° | 0.51 | 0.75 |
| Option H1 (Desaturated Brown) | 192, 135, 104 | 21° | 0.46 | 0.75 |
| Option H2 (Hex Color Code) | 200, 143, 109 | 22° | 0.46 | 0.78 |

Both reduced saturation from 0.51 to 0.46, halving the gap with ground truth. Option H1 preserved ground-truth brightness, yielding the closest visual match.
Refined Character Descriptions (v2 and v3)
Revisiting ground-truth images, I refined the descriptors with specific traits: straight hair conforming to the scalp, tapered uneven ends, a single center bang, specific ponytail thickness, forward-curving ahoge, and khaki-brown eyes with a single highlight:
| Version | Key Adjustments | Result |
|---|---|---|
| v2 | Added granular hair and style descriptions; 16–17 years old, 6.5 heads tall | Hair became straighter with less volume, closer to ground truth, but extended too long past the chest; bench scene remained youthful |
| v3 | Specified collarbone hair length, Option B body (late teens, 7 heads), and eyes not oversized | Uniform hair length matched ground truth; portrait exhibited a larger ahoge; bench scene still leaned youthful |

Hair styling responded directly to prompt instructions. In bench scenes, facial descriptors like “round face” and “small nose dot” may pull overall stature toward a younger appearance.
Tag-Style Prompts
Following mage.space’s suggestion that anime styling aligns naturally with structured tag lists (Quality → Score → Meta → Year → Character → Series → Artist → General), I evaluated tag prompts with and without the step 3,000 LoRA:
masterpiece, best quality, score_7, safe, anime coloring, 1girl, solo, kanachan, light brown hair, medium hair, side ponytail, blue scrunchie, ahoge, hair between eyes, brown eyes, blush, small breasts, school uniform, white shirt, collared shirt, long sleeves, red necktie, grey skirt, pleated skirt, black pantyhose, brown footwear, loafers, full body, standing, arms at sides, looking at viewer, closed mouth, smile, straight-on, simple background, white background
| Condition | Full Body Uniform | Park Bench |
|---|---|---|
| Tag format, no LoRA | Small head, long legs, light brown hair; unrelated character | Clean anime rendering; unrelated character |
| Tag format, step 3,000 LoRA | Small head, closer to ground-truth proportions than prose prompts; ponytail and ahoge emerged cleanly | Mature stature compared to prose v3 |
| Prose v3, step 3,000 LoRA | Head slightly large | Stature leaned youthful |

Tag formatting naturally yielded flatter cel shading and mature body proportions. The proportions that required extensive tuning in prose appeared effortlessly under tag formatting.
Because the v1 dataset eliminated tags in favor of prose, MOSS-Image may associate anime styling more strongly with tag conventions.
A Hybrid Caption Approach Combining Tags and Natural Language
Because tag-based prompts aligned closely with target aesthetics, I constructed a second dataset configuration (v2) combining prefix quality tags, natural language descriptions, and Danbooru tags:
| Adjustment | Details |
|---|---|
| Image Filtering | Excluded non-safe ratings (same 70 images as v1) |
| Phrasing | Simplified a young girl and a young slender girl to a girl (63 images) |
| Trailing Tags | Removed body shape and color tags (flat chest, slim, brown hair, brown eyes) |
| Prefix Tags | Unified all prefixes to masterpiece, best quality, score_7, safe, 1girl, solo, kanachan, |
Sample v2 caption:
masterpiece, best quality, score_7, safe, 1girl, solo, kanachan, A girl wearing a reddish brown school blazer over a white collared shirt with red necktie. She has an angry expression with a fang and open mouth, captured mid-action with one fist clenched. Her side ponytail with a blue scrunchie is visible on the right side of the image. side ponytail, ahoge, double parted bangs, medium hair, blue scrunchie, reddish brown blazer, white collared shirt, red necktie, angry, fang, open mouth, looking to the side, upper body, action pose, white background, simple background
Caption length ranged from 36 to 111 words (average 70.8).
Omitting body type and hair/eye colors encourages binding those invariant traits to the kanachan trigger rather than descriptive adjectives.
Dataset assets were staged at ~/train/datasets/kana_moss_v2/ with config at ~/train/configs/kana_moss_v2.yaml.
Comparing with Other Published LoRA Setups
Reviewing community practices and tooling docs for MOSS-Image character LoRAs:
| Source | Setup Details |
|---|---|
| tachiyumi/MOSS-Image-LoRAs | 4 anime character LoRAs. Trained on MOSS-Image Base at rank 32. Rewritten natural language captions without trailing tags; invariant traits omitted. Prompts use alya(anime), <description>. Inferred with Euler, 50 steps, CFG 3.0 |
loras.json in same repo | 1,800 to 12,000 steps across 60–120 frames. Recommended strength 0.85–1.0 |
| imagelora.dev Guide | Omit baked traits from captions; describe only variable elements. 100–200 images recommended. ~2,000 steps for small datasets, ~3,000 for characters. Suggests higher ranks and CFG 3–4 for evaluation |
| kohya-ss/sd-scripts Docs | MOSS-Image was pretrained on long VLM captions. Pretraining timestep distribution matches truncated_logit_normal |
| sorryhyun/anima_lora Docs | Can train on Anima-style tags, but defaults to converting to MOSS JSON format. Omit quality tags. Default rank 32, lr 5e-5 |
| axiomofmind/Moss-image-anime-lora | Style LoRA; 79 images, 2,000 steps, rank 16, lr 1e-4, natural captions. Trained on Base, inferred on SFT |
| Raehoshi Moss Image | ~10k image anime checkpoint trained across 4 caption styles (full tag, long, medium, short prose) |
Key differences from our run:
| Dimension | Our Run | External Examples |
|---|---|---|
| Captions | Natural prose; hair descriptions retained in 49/70 images | Natural prose omitting trigger-bound invariant traits |
| LoRA Rank | 16 | Rank 32 across all 4 tachiyumi character models |
| Step Count | 2,000–3,000 across 70 images (~29–43 repeats per image) | Ranges from 20 to 100 repeats per image |
| Timestep Schedule | ai-toolkit default (sigmoid) | Dedicated schedules aligned with pretraining |
The principle of omitting invariant features from captions was shared across airmore.ai, imagelora.dev, and tachiyumi.
Applying the LoRA to an Anime Fine-Tuned Checkpoint
Raehoshi Moss Image v1.0 is an anime checkpoint fine-tuned from MOSS-Image Base on ~10,000 anime images, merged with a rank-128 SFT LoRA. I tested whether our 3,000-step Base-trained LoRA transfers cleanly to this checkpoint.
Recommended settings: ER SDE sampler, SGM Uniform scheduler, 30–50 steps, CFG 4.5, with SLG enabled across layers [22, 24, 26]:
--sampling-method er_sde --scheduler sgm_uniform --steps 30 --cfg-scale 4.5 \
--skip-layers "[22,24,26]" --skip-layer-start 0 --skip-layer-end 0.5 \
--extra-sample-args slg_uncond=1
Testing tag-format prompts at seed 42:
| Setup | Generation Time | Full Body Uniform | Park Bench |
|---|---|---|---|
| Recommended, no LoRA | 722 s, 747 s | Unrelated character; game-style detailed illustration | Unrelated character |
| Recommended, step 3,000 LoRA | 691 s, 723 s | Brown hair, ahoge, and blue scrunchie ponytail emerged cleanly; compact head ratio matching ground truth | Identity features appeared; mature body proportions; lower legs cropped at frame edge |
| 4-step LoRA, step 3,000 LoRA | 59 s, 62 s | Near-identical character rendering | Identity preserved, but composition and limbs degraded |

The Base-trained LoRA transferred directly to the fine-tuned anime checkpoint. Without LoRA, the model produced an unrelated face; with LoRA, hairstyle and hair color matched accurately. The art style shifted toward the checkpoint’s intricate shading while preserving character hallmarks.
While the SFT 4-step LoRA functioned, scene composition degraded in complex prompts, suggesting distilled inference on this checkpoint is reliable only for straightforward compositions.
Summary and Next Steps
Key takeaways from local training on the EVO-X2:
| Finding | Supporting Evidence |
|---|---|
| ROCm on EVO-X2 trains 1024px MOSS-Image LoRAs reliably | Completed 3,000 steps without crashes (~35 s/step, ~19 hours for 2,000 steps) |
| Base-trained LoRA weights transfer across Base, SFT, 4-step distilled SFT, and community anime fine-tunes | Validated across multiple generation pipelines |
| Character identity requires explicit prompt guidance | Hairstyle descriptions remained in 49/70 captions, binding traits to prose rather than trigger |
| Steps 2,000 to 3,000 primarily shifted eye color | Proportions and hair hue remained stable |
| Stature and head-to-body ratio are strongly influenced by prompt phrasing | Steered via age descriptors and tag-based formatting |
Areas for follow-up testing:
- Caption Strategy: Stripping invariant traits (hair, eye color, stature) from captions to force absorption into the trigger word
- Caption Format: Comparing pure prose against hybrid tag-and-prose structures
- LoRA Rank: Evaluating rank 32 against rank 16
- Repeat Count: Benchmarking 20 to 100 repeats per image
- Timestep Scheduling: Testing schedules matched to MOSS-Image pretraining
At ~35 seconds per step, iterating through these parameter permutations locally requires roughly 19 hours per run. Subsequent parameter sweeps will be executed on dedicated cloud GPUs such as RunPod, using the v2 dataset prepared here as the baseline.