File size: 6,736 Bytes
82f1be4 c7ee53a 82f1be4 c7ee53a 4568b9d c7ee53a 2c9544e c7ee53a 4568b9d c7ee53a 4568b9d c7ee53a 4568b9d c7ee53a 4568b9d c7ee53a 4568b9d c7ee53a 4568b9d c7ee53a 4568b9d c7ee53a bb7c50f c7ee53a bb7c50f c7ee53a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 | ---
license: mit
tags:
- inline-studio
- character
- lora
- flux2
- krea2
---
# Unified Face Models
Character files that work on more than one image model. Each one carries FLUX.2 reference images
and a trained Krea 2 adapter in the same 107 MB container, so the same face renders on either
model without keeping two sets of files in sync.
| File | Krea 2 adapter trained on | Train resolution | Apply strength |
| --- | --- | --- | --- |
| `emmy-s500-v2.char` | Krea 2 **Turbo** (`krea2_turbo_bf16`) | 1024 | 0.5 |
| `emmy-s5.char` | Krea 2 **RAW** (`krea2_raw_bf16`) | 512 | 1.0 |
Same five references and same description in both, so their FLUX.2 side is identical. They differ
only in how the Krea 2 adapter was trained, and both are published so the two can be compared on
the same face.
Built and trained on the canvas in [Inline Studio](https://github.com/inlineresearch/Inline-Studio).
## Comparisons
The same character rendered from the same `.char`, so the differences come from the model and the
adapter rather than from the references.
| | |
| --- | --- |
|  |  |
|  |  |
## Why one file holds two things
FLUX.2 klein and Krea 2 accept a character in completely different ways, so a single artifact
cannot work for both.
FLUX.2 klein has a reference channel. Reference images become tokens the model attends to at every
denoising step, which is why a prompt can address them by position. Feeding it resized copies of
the originals is enough, and no training is involved.
Krea 2 has no reference channel. Its image input is ordinary img2img: the picture is encoded once
into the starting latent and then denoised away, so there is nothing left for the model to hold on
to. The only way to give Krea 2 a persistent identity is a trained LoRA.
A `.char` stores identity once and compiles a payload per model family:
```
emmy-s500-v2.char
manifest.json payload index, fingerprints, training record
refs/000..004.png the 5 reference images, immutable
derived/face_000..004.png YuNet face crops at 512px
text/description.md the locked description, which is also the trigger
scoring/centroid_sface.json 128-d SFace identity centroid
scoring/centroid_dinov2-base.json 768-d DINOv2 subject centroid
scoring/embeds_*.json per-reference embeddings
payloads/flux2-klein/ref_000..004.png references resized onto FLUX.2's policy
payloads/krea2-lora/adapter.safetensors the trained Krea 2 LoRA, 183 MB
```
The references and the description are the truth. Everything under `payloads/` and `scoring/` is
cache and can be rebuilt from `refs/`. Adding a third model means adding a payload, not rebuilding
the character.
## What is in them
Shared by both files:
| | |
| --- | --- |
| References | 5 images, three at 2048px and two at 640px |
| Trigger | `emmy4k woman with, natural unretouched skin, black hairs, fair skin` |
| FLUX.2 payload | `flux2-klein`, 5 compiled references, max 1 MP, dimensions rounded to a multiple of 16 |
| Krea 2 payload | `krea2-lora`, one 183 MB adapter |
### Krea 2 training
`emmy-s500-v2.char`, trained on Turbo:
| | |
| --- | --- |
| Base | `krea2_turbo_bf16.safetensors` (Krea 2 Turbo) |
| Steps | 500 |
| Rank | 16 |
| Resolution | 1024 |
| Apply strength | 0.5 |
`emmy-s5.char`, trained on RAW:
| | |
| --- | --- |
| Base | `krea2_raw_bf16.safetensors` (Krea 2 RAW) |
| Steps | 500 |
| Rank / alpha | 16 / 16 |
| Learning rate | 1e-4, constant, Adam8bit |
| Resolution | 512 |
| Batch size | 1 |
| Scope | full (attention + feed-forward) |
| Caption dropout | 0.05 |
| Apply strength | 1.0 |
The RAW file came first, and training on RAW was deliberate: Turbo is step-distilled, and an
adapter trained on RAW loads onto Turbo afterwards anyway. The Turbo file tests that directly by
training on Turbo itself, at 1024 rather than 512, and applying at half strength.
Every training image used the description above as its caption in both runs, so `emmy4k` is what
each adapter binds to.
The 500-step checkpoint beat the 800-step one on the same references. With five images that is 100
passes each, and past roughly that point the adapter starts returning the training frames instead
of the person in them.
## Using it
Drop the file in `models/characters/` and add a **Load Character** node, then wire it into the
`character` input of a FLUX.2 or Krea 2 node.
Inline Studio picks the payload for whichever model you wired it to. FLUX.2 gets the five
references and a prompt line naming their positions. Krea 2 gets the adapter. Either way the
description is prepended to your prompt, so type only what changes:
```
walking on a forest trail, half body shot
```
Not the description again. It is already there, and repeating it pushes the adapter harder toward
the frames it trained on.
For Krea 2, generate with **Krea 2 Turbo** at 8 steps and guidance 0, whichever file you use. The
RAW-trained adapter loads onto Turbo as intended, and the Turbo-trained one was built against it.
Each file carries its own apply strength, 1.0 for the RAW one and 0.5 for the Turbo one, so leave
the strength alone unless you are deliberately dialling the identity up or down.
## Building your own
The full graph that produced this file, from five photos to a `.char` with both payloads, is
published here:
[FLUX.2 + Krea 2: multi-model portable consistent characters](https://inlinestudio.art/workflows/flux-2-krea-2-multi-model-portable-consistent-characters-training-only)
Import it into Inline Studio, swap the reference images, and run the graph. It encodes the
character, compiles the FLUX.2 references, builds a training dataset from the same references,
trains the Krea 2 LoRA, attaches it, and writes the `.char`.
## Related Workflows
- [Flux 2: Portable consistent characters, without LoRA training](https://inlinestudio.art/workflows/flux-2-portable-consistent-characters-without-lora-training)
- [Flux 2 + Krea 2: Multi model portable consistent characters, Training only](https://inlinestudio.art/workflows/flux-2-krea-2-multi-model-portable-consistent-characters-training-only)
- [Krea 2: Generate consistent images with unified .char model](https://inlinestudio.art/workflows/krea-2-generate-consistent-images-with-unified-char-model)
- [Flux 2 Klein: Generate consistent images with unified .char model](https://inlinestudio.art/workflows/flux-2-klein-generate-consistent-images-with-unified-char-model)
## License
MIT. The reference images are the character's own; check that you have the rights to any faces you
train on before publishing a `.char`.
|