Flux Brand Finetune

FLUX Brand Fine-Tune

Train custom LoRA models on FLUX Dev for consistent Alex (or any character) imagery across all generated content.

Pattern: Train once with 10–20 curated images → get a trigger-word-activated LoRA → generate unlimited consistent images at ~$0.003–0.04/image.

Staleness Watch: See EXTERNAL-API-REGISTRY.md for source URLs and recheck cadence

Why Fine-Tune?

Fine-tuning wins when you need hundreds of images across marketing, docs, presentations, and social media — all with the same character looking exactly the same without passing reference images every time.

Trainer Models

Recommendation: Use replicate/fast-flux-trainer for most use cases — faster, cheaper, simpler.

Training Data Requirements

Image Guidelines

For Character/Subject LoRAs

• Include varied backgrounds (indoor, outdoor, studio, natural)
• Show different facial expressions (neutral, smiling, serious, thoughtful)
• Use different clothing styles
• Mix lighting conditions (natural, studio, dramatic)
• Avoid: different haircuts or ages, excessive hand-near-face poses

For Style LoRAs

• Select images highlighting the distinctive style features
• Use varied subjects while keeping style consistent
• Avoid datasets where certain elements dominate

Optional: Custom Captions

Place a .txt file alongside each image with the same name:

alex-front.jpg      → alex-front.txt
alex-profile.jpg    → alex-profile.txt
alex-outdoor.jpg    → alex-outdoor.txt

If captions aren't provided, the trainer auto-generates them using LLaVA.

Trigger Word Selection

The trigger word activates your LoRA concept in prompts.

Rules:

• Must be unique — NOT a real word in any language
• NOT TOK (clashes with other fine-tunes)
• Case-insensitive but ALL CAPS helps visually
• Short, memorable

Examples:

• ALEXFNCH — Alex Finch character
• CXRBRAND — CorreaX brand style
• ALEXCOG — Alex cognitive architecture style

Training Workflow

Step 1: Prepare Training Data

# Create a training data folder
New-Item -ItemType Directory -Path "training-data" -Force

# Optionally resize images to 1024px (if oversized)
# Requires ImageMagick:
# macOS: brew install imagemagick
# Windows: winget install ImageMagick.ImageMagick
Get-ChildItem training-data/*.jpg, training-data/*.png | ForEach-Object {
    magick $_.FullName -resize "1024x1024>" $_.FullName
}

# Zip the training data
Compress-Archive -Path "training-data/*" -DestinationPath "training-data.zip" -Force

Step 2: Upload Training Data

Upload the zip to a publicly accessible URL, or use the Replicate web UI to upload directly.

import { readFileSync } from "fs";

// Option A: Use Replicate's file upload
const replicate = new Replicate({ auth: process.env.REPLICATE_API_TOKEN });
// Upload via the web UI at https://replicate.com/replicate/fast-flux-trainer/train

// Option B: Use any file hosting (S3, Azure Blob, etc.)
// The URL must be publicly accessible during training

Step 3: Create Training via API

import Replicate from "replicate";

const replicate = new Replicate({ auth: process.env.REPLICATE_API_TOKEN });

const training = await replicate.trainings.create(
  "replicate",           // model owner
  "fast-flux-trainer",   // model name
  "8b10794665aed907bb98a1a5324cd1d3a8bea0e9b31e65210967fb9c9e2e08ed",  // version
  {
    destination: "your-username/alex-brand",  // your model destination
    input: {
      input_images: "https://your-storage.com/training-data.zip",
      trigger_word: "ALEXFNCH",
      lora_type: "subject",           // "subject" or "style"
      // training_steps: 1000,        // default 1000, range 500–4000
    }
  }
);

console.log("Training started:", training.id);
console.log("Status URL:", training.urls.get);

Step 3 (Alternative): Create Training via curl

curl -X POST \
  -H "Authorization: Bearer $REPLICATE_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "destination": "your-username/alex-brand",
    "input": {
      "input_images": "https://your-storage.com/training-data.zip",
      "trigger_word": "ALEXFNCH",
      "lora_type": "subject"
    }
  }' \
  https://api.replicate.com/v1/models/replicate/fast-flux-trainer/versions/8b10794665aed907bb98a1a5324cd1d3a8bea0e9b31e65210967fb9c9e2e08ed/trainings

Step 4: Monitor Training

// Poll for status
const status = await replicate.trainings.get(training.id);
console.log("Status:", status.status);  // starting → processing → succeeded/failed

# Or via curl
curl -s \
  -H "Authorization: Bearer $REPLICATE_API_TOKEN" \
  https://api.replicate.com/v1/trainings/<training_id>

Training typically completes in ~2 minutes with the fast trainer.

Step 5: Generate Images with Your LoRA

Once training succeeds, your model is live at the destination:

const output = await replicate.run(
  "your-username/alex-brand",  // your trained model
  {
    input: {
      prompt: "ALEXFNCH standing in a modern office, wearing a casual blue shirt, " +
              "confident smile, natural lighting, professional photography, 8k detail",
      aspect_ratio: "3:4",
      output_format: "png",
    }
  }
);

// Save immediately — output URLs expire after 1 hour
import { writeFile } from "node:fs/promises";
await writeFile("alex-office.png", output);

Advanced Training Parameters

ostris/flux-dev-lora-trainer (Full Control)

replicate/fast-flux-trainer (Recommended)

Using Your LoRA with Other Flux Models

Your trained LoRA weights can be used with any Flux model that supports LoRA:

// Use with Flux Dev (good quality, $0.025/image)
const output = await replicate.run("black-forest-labs/flux-dev", {
  input: {
    prompt: "ALEXFNCH in a coffee shop, reading a book",
    extra_lora: "your-username/alex-brand",
    extra_lora_scale: 1.0,   // 0.0–1.5, default 1.0
  }
});

// Use with Flux Schnell (fast iteration, $0.003/image)
const output = await replicate.run("black-forest-labs/flux-schnell", {
  input: {
    prompt: "ALEXFNCH giving a presentation",
    extra_lora: "your-username/alex-brand",
  }
});

LoRA Scale Tuning

Cost Analysis

Break-even vs Nano-Banana Pro: After ~70 images ($0.025 × 70 = $1.75 > $1.50 training), the fine-tune pays for itself and every subsequent image costs only $0.003–0.025 without needing reference photos.

Prompt Engineering for Fine-Tuned Models

Template

TRIGGER_WORD [description of scene], [clothing], [expression], [lighting], [style]

Best Practices

1. Always lead with trigger word: ALEXFNCH standing in a park not A person standing in a park named ALEXFNCH
2. Be specific about scene: FLUX follows detailed prompts well
3. Don't describe physical features: The LoRA handles identity — describe scene, clothing, mood
4. Use quality tokens: "professional photography", "8k detail", "cinematic lighting"

Example Prompts

ALEXFNCH headshot, professional business attire, confident smile, studio lighting, corporate portrait photography

ALEXFNCH sitting at a desk with multiple monitors, coding, casual hoodie, night time, ambient screen glow, documentary photography

ALEXFNCH presenting at a tech conference, standing on stage, gesturing toward a screen, audience in background, event photography

ALEXFNCH in a cozy library, reading a leather-bound book, warm lamplight, bokeh background, editorial photography

Visual Verification (VS Code 1.112+)

After generating with your LoRA, use view_image to evaluate output quality:

1. Identity fidelity — Does the character match the training data?
2. Prompt adherence — Does the scene match the prompt, or is the LoRA overfitting?
3. LoRA scale tuning — Compare outputs at 0.6, 0.8, 1.0 to find the sweet spot
4. Artifact scan — Check for training artifacts: repeated backgrounds, frozen expressions, texture smearing

When iterating on LoRA scale or prompt structure, compare outputs side-by-side via the image carousel.

Retraining and Iteration

When to Retrain

• Character design changed significantly
• Original training data was insufficient (< 10 images)
• Want to add new scenarios not well-represented
• Trigger word conflicts with another LoRA

Iteration Strategy

1. Generate 10 test images with varied prompts
2. Evaluate: Does the face/identity hold across scenes?
3. If weak: add more training images in the weak areas
4. Retrain with expanded dataset (training is cheap at ~$1.50)

Integration with Visual Memory

If you have a visual-memory.json with reference photos, extract the base64 images back to files for training:

import { readFileSync, writeFileSync } from "fs";
import { join } from "path";

const vmPath = ".github/skills/<skill>/visual-memory/visual-memory.json";
const vm = JSON.parse(readFileSync(vmPath, "utf8"));

// Extract images from visual memory for training
Object.entries(vm.subjects).forEach(([name, subject]) => {
  subject.images.forEach((img, i) => {
    const base64 = img.dataUri.split(",")[1];
    const buffer = Buffer.from(base64, "base64");
    writeFileSync(join("training-data", `${name}-${i}.jpg`), buffer);
  });
});

Security Considerations

• Training images of real people are PII — use private models on Replicate
• Store REPLICATE_API_TOKEN in VS Code SecretStorage, not in code
• Output URLs expire after 1 hour — save generated images immediately
• Keep training data zip in a secure location, not in public repos
• Fine-tuned model can be set to private on Replicate

Troubleshooting