lora.exe

LoRA

Low-Rank Adaptation, and how I train one on my own work

Nadeschda Barenje

vetroal.se / EXTERN_AI / 2026

A small layer of my own, riding on a model trained by everyone else.
Who creates when control is distributed?

what_is_a_lora.txt

What a LoRA is

A large image model like Stable Diffusion holds its knowledge in hundreds of millions of numbers, its weights. Retraining all of them to teach the model something new is slow and needs heavy hardware. A LoRA, short for Low-Rank Adaptation, takes another route. The original weights are frozen and left untouched. Instead, a thin set of new, trainable numbers is added beside them, and only that thin set learns.

The trick is in the word low-rank. Rather than learning a full grid of adjustments, a LoRA learns two small matrices whose product approximates the change you want. A handful of million numbers stands in for an edit that would otherwise need hundreds of millions. The base model still does the heavy lifting of rendering a coherent image; the LoRA only leans on it, nudging it toward a particular subject or surface.

Frozen base model + a small trained layer = the base model's competence, steered toward something specific. The method comes from Hu et al., "LoRA: Low-Rank Adaptation of Large Language Models" (2021).

How I use it

For EXTERN_AI I train a LoRA on photographs of my own glass and ceramic sculptures. The base is runwayml/stable-diffusion-v1-5, frozen. On top of it I train a layer of about 12.7 million parameters at rank 64, so the model learns the forms, surfaces and light of my work without forgetting how to make an image at all.

Each training image is captioned with a trigger word, nadja_art. Once trained, writing that word into a prompt is what wakes the learned layer; without it the model drifts back to generic scenes. I generate at 384 px to stay inside the 6 GB of my GTX 1660 Super, and I vary prompt, guidance and sampler heavily between images so the outputs stay different from one another rather than ten versions of the same picture.

My configuration

Setting	Value	Why
Base model	Stable Diffusion 1.5	Frozen, never retrained
Method	LoRA, rank 64 / alpha 32	Enough capacity for a style, not so much it breaks images
Trainable size	~12.7 million parameters	The part that is mine
Trigger word	`nadja_art`	Activates the learned layer
Generation size	384 px	Fits 6 GB VRAM without out-of-memory

python generate_wild.py \
  --checkpoint ./checkpoints/epoch_050 \
  --trigger "nadja_art" \
  --size 384 --guidance 4-14 --vary-prompt

the_process.exe

The process, step by step

STEP 1 The training set: my own photographs

I photograph my finished sculptures and process work, then caption each image with the trigger word. This is the only material the layer ever learns from. A few hundred photographs of my glass, ceramics and cast forms, nothing borrowed.

Sample of the training set: real photographs of my own glass and ceramic work, each captioned with the trigger word.

STEP 2 The frozen base, my thin layer on top

Training does not touch Stable Diffusion's own weights. It only adjusts the small low-rank matrices added beside them. The base keeps everything it learned from billions of images; my layer learns the narrow thing it never saw, my work.

The narrow band is small, frozen weights below, image above, but it is the band that aims the whole stack.

STEP 3 What it generates

With the trigger word in the prompt, the model produces new forms that read as mine. The surfaces are mine, and so is the way light sits in a body. These are pure outputs, no photo retouched, generated at 384 px and varied across seeds and prompts. Some come out so convincing they look like documentation of a piece I never made.

Generated with the trained layer. The first rows are nearly photographic; the later ones stay rawer and more abstract. Filenames carry their seeds, e.g. nadja_050_seed3050.

STEP 4 Back into glass

A generated image is not the end. I read one as a proposal and bring it back into matter. For The Glass Child I took the image the LoRA generated, built a 3D model from it, printed and moulded it, and cast the form in glass. The model returns my work to me changed, and I answer it in the kiln.

The Glass Child, cast glass — The Glass Child (2026). Cast glass, modelled and moulded from an EXTERN_AI generated image.

EXTERN_AI github.com/jinkieyz SD 1.5 + LoRA

how_much_is_mine.exe

How much of it is based on my work?

This is the question I keep returning to. Two honest answers exist, and they point in opposite directions. By sheer quantity my share is almost nothing. By effect, it decides everything you see.

By parameters

The part of the base model my LoRA attaches to holds roughly 860 million numbers. My trained layer adds about 12.7 million on top. That is close to 1.5% of the total, around one part in seventy.

base model (everyone else's training) my trained layer

The blue sliver on the right edge is the whole of what I trained.

By training images

The base model learned from on the order of 2.3 billion images scraped from the open web. I trained on a few hundred photographs of my own sculptures. Drawn to the same scale, my contribution is thinner than a single drawable line.

My few hundred photographs are the 1-pixel mark at the far right.

By effect

And yet that thin layer is the steering. The base supplies the raw ability to render glass, light and form; the trigger word and my 12.7 million numbers decide that it renders my glass, my forms, the surfaces I cast and blow. Remove the layer and the same prompt drifts off into stock landscapes and strangers' faces.

So the truthful answer is double: numerically negligible, and at the same time the deciding hand. The model is built from everyone. The aim is mine.

EXTERN_AI is part of Hard Copy. Silicon all the way: sand to glass, glass to lens, lens to GPU, GPU to image, image back to glass.

Nadeschda Barenje vetroal.se/lora 2026