scripts/training/train_flux_lora.py

"""
Fine-tune Flux with LoRA - 2 GPU split (encode on GPU0, train on GPU1).
Reads webdataset shards directly. Supports resume from checkpoint.
Follows diffusers reference implementation for correct flow matching.
"""
import argparse
import gc
import io
import math
import time
from pathlib import Path

import torch
import torch.nn.functional as F
import webdataset as wds
from PIL import Image
from torchvision import transforms
from peft import LoraConfig, get_peft_model, set_peft_model_state_dict


def get_train_transforms(resolution=1024):
    return transforms.Compose([
        transforms.Resize(resolution, interpolation=transforms.InterpolationMode.LANCZOS),
        transforms.CenterCrop(resolution),
        transforms.ToTensor(),
        transforms.Normalize([0.5], [0.5]),
    ])


def collate_batch(samples):
    images = torch.stack([s["image"] for s in samples])
    captions = [s["caption"] for s in samples]
    return {"image": images, "caption": captions}


def create_webdataset(data_dir, resolution=1024, batch_size=1):
    transform = get_train_transforms(resolution)

    def preprocess(sample):
        try:
            image = sample["jpg"]
            if isinstance(image, bytes):
                image = Image.open(io.BytesIO(image)).convert("RGB")
            caption = sample.get("txt", b"")
            if isinstance(caption, bytes):
                caption = caption.decode("utf-8")
            return {"image": transform(image), "caption": caption}
        except Exception:
            return None

    tar_files = sorted(Path(data_dir).glob("*.tar"))
    if not tar_files:
        raise ValueError(f"No tar files found in {data_dir}")
    print(f"  Found {len(tar_files)} shards")

    dataset = (
        wds.WebDataset([str(f) for f in tar_files], shardshuffle=True, empty_check=False)
        .shuffle(1000)
        .decode("pil")
        .map(preprocess)
        .select(lambda x: x is not None)
        .batched(batch_size, collation_fn=collate_batch)
    )
    return dataset, len(tar_files)


def pack_latents(latents, batch_size, num_channels, height, width):
    latents = latents.view(batch_size, num_channels, height // 2, 2, width // 2, 2)
    latents = latents.permute(0, 2, 4, 1, 3, 5)
    latents = latents.reshape(batch_size, (height // 2) * (width // 2), num_channels * 4)
    return latents


def unpack_latents(latents, height, width, num_channels):
    batch_size = latents.shape[0]
    latents = latents.reshape(batch_size, height // 2, width // 2, num_channels, 2, 2)
    latents = latents.permute(0, 3, 1, 4, 2, 5)
    latents = latents.reshape(batch_size, num_channels, height, width)
    return latents


def prepare_latent_image_ids(height, width, device, dtype):
    latent_image_ids = torch.zeros(height, width, 3, device=device, dtype=dtype)
    latent_image_ids[..., 1] = latent_image_ids[..., 1] + torch.arange(height, device=device, dtype=dtype)[:, None]
    latent_image_ids[..., 2] = latent_image_ids[..., 2] + torch.arange(width, device=device, dtype=dtype)[None, :]
    return latent_image_ids.reshape(height * width, 3)


def compute_density_for_timestep_sampling(weighting_scheme, batch_size, logit_mean=0.0, logit_std=1.0):
    if weighting_scheme == "logit_normal":
        u = torch.normal(mean=logit_mean, std=logit_std, size=(batch_size,))
        u = torch.sigmoid(u)
    elif weighting_scheme == "mode":
        u = torch.rand(batch_size)
        u = 1 - u - 0.2 * (torch.cos(math.pi * u / 2) ** 2 - 1 + u)
    else:
        u = torch.rand(batch_size)
    return u


def compute_loss_weighting(weighting_scheme, sigmas):
    if weighting_scheme == "sigma_sqrt":
        weighting = (sigmas ** -2.0)
        return weighting.clamp(max=10.0)
    elif weighting_scheme == "cosmap":
        return 2.0 / (math.pi * (1 - 2 * sigmas + 2 * sigmas ** 2))
    else:
        return torch.ones_like(sigmas)


def find_latest_checkpoint(output_dir):
    output_dir = Path(output_dir)
    if not output_dir.exists():
        return None, 0
    checkpoints = sorted(
        [d for d in output_dir.iterdir() if d.is_dir() and d.name.startswith("checkpoint-")],
        key=lambda p: int(p.name.split("-")[1]) if p.name.split("-")[1].isdigit() else 0,
    )
    if checkpoints:
        step = int(checkpoints[-1].name.split("-")[1])
        return checkpoints[-1], step
    return None, 0


@torch.no_grad()
def generate_samples(
    transformer, vae, text_encoder, text_encoder_2,
    tokenizer, tokenizer_2,
    prompts, output_dir, global_step,
    encode_device, train_device,
    num_inference_steps=28, guidance_scale=3.5,
):
    from diffusers import FluxPipeline

    output_dir = Path(output_dir) / "samples"
    output_dir.mkdir(parents=True, exist_ok=True)

    transformer.eval()

    # Move all components to same device for inference
    gen_device = train_device
    vae.to(gen_device)
    text_encoder.to(gen_device)
    text_encoder_2.to(gen_device)

    try:
        pipe = FluxPipeline.from_pretrained(
            "black-forest-labs/FLUX.1-dev",
            transformer=transformer,
            vae=vae,
            text_encoder=text_encoder,
            text_encoder_2=text_encoder_2,
            tokenizer=tokenizer,
            tokenizer_2=tokenizer_2,
            torch_dtype=torch.bfloat16,
        )
        pipe = pipe.to(gen_device)

        for i, prompt in enumerate(prompts):
            image = pipe(
                prompt=prompt,
                num_inference_steps=num_inference_steps,
                guidance_scale=guidance_scale,
                height=512,
                width=512,
            ).images[0]
            image.save(output_dir / f"step_{global_step:06d}_sample_{i}.png")

        del pipe
    except Exception as e:
        print(f"  WARNING: Sample generation failed: {e}")

    # Move components back to encode_device for training
    vae.to(encode_device)
    text_encoder.to(encode_device)
    text_encoder_2.to(encode_device)

    transformer.train()
    torch.cuda.empty_cache()


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--model-name", default="black-forest-labs/FLUX.1-dev")
    parser.add_argument("--data-dir", type=Path, required=True)
    parser.add_argument("--output-dir", type=Path, required=True)
    parser.add_argument("--cache-dir", default="/data0/models")
    parser.add_argument("--resolution", type=int, default=1024)
    parser.add_argument("--batch-size", type=int, default=1)
    parser.add_argument("--gradient-accumulation", type=int, default=8)
    parser.add_argument("--learning-rate", type=float, default=1e-4)
    parser.add_argument("--lr-scheduler", default="constant")
    parser.add_argument("--lr-warmup-steps", type=int, default=100)
    parser.add_argument("--max-train-steps", type=int, default=999999999)
    parser.add_argument("--save-steps", type=int, default=2000)
    parser.add_argument("--sample-steps", type=int, default=2000)
    parser.add_argument("--lora-rank", type=int, default=128)
    parser.add_argument("--lora-alpha", type=int, default=64)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--encode-device", default="cuda:0")
    parser.add_argument("--train-device", default="cuda:1")
    parser.add_argument("--resume-from-checkpoint", default="auto")
    parser.add_argument("--guidance-scale", type=float, default=1.0)
    parser.add_argument("--weighting-scheme", default="none", choices=["none", "logit_normal", "mode", "sigma_sqrt", "cosmap"])
    parser.add_argument("--logit-mean", type=float, default=0.0)
    parser.add_argument("--logit-std", type=float, default=1.0)
    parser.add_argument("--max-grad-norm", type=float, default=1.0)
    args = parser.parse_args()

    args.output_dir.mkdir(parents=True, exist_ok=True)
    torch.manual_seed(args.seed)

    encode_device = torch.device(args.encode_device)
    train_device = torch.device(args.train_device)

    if torch.cuda.device_count() < 2:
        print("  Only 1 GPU, using same device for encode + train")
        encode_device = torch.device("cuda:0")
        train_device = torch.device("cuda:0")

    # Resume logic
    resume_path, resume_step = None, 0
    if args.resume_from_checkpoint == "auto":
        resume_path, resume_step = find_latest_checkpoint(args.output_dir)
        if resume_path:
            print(f"  Resuming from {resume_path} (step {resume_step})")

    # Load tokenizers
    print("  Loading tokenizers...")
    from transformers import CLIPTokenizer, T5TokenizerFast
    tokenizer = CLIPTokenizer.from_pretrained(args.model_name, subfolder="tokenizer", cache_dir=args.cache_dir)
    tokenizer_2 = T5TokenizerFast.from_pretrained(args.model_name, subfolder="tokenizer_2", cache_dir=args.cache_dir)

    # Load VAE + text encoders on encode_device
    print(f"  Loading VAE + text encoders on {encode_device}...")
    from diffusers import AutoencoderKL
    from transformers import CLIPTextModel, T5EncoderModel

    vae = AutoencoderKL.from_pretrained(
        args.model_name, subfolder="vae", torch_dtype=torch.bfloat16, cache_dir=args.cache_dir
    ).to(encode_device).eval()
    vae.requires_grad_(False)

    text_encoder = CLIPTextModel.from_pretrained(
        args.model_name, subfolder="text_encoder", torch_dtype=torch.bfloat16, cache_dir=args.cache_dir
    ).to(encode_device).eval()
    text_encoder.requires_grad_(False)

    text_encoder_2 = T5EncoderModel.from_pretrained(
        args.model_name, subfolder="text_encoder_2", torch_dtype=torch.bfloat16, cache_dir=args.cache_dir
    ).to(encode_device).eval()
    text_encoder_2.requires_grad_(False)

    vae_shift = vae.config.shift_factor
    vae_scale = vae.config.scaling_factor
    print(f"  VAE config: shift_factor={vae_shift}, scaling_factor={vae_scale}")

    # Load transformer on train_device
    print(f"  Loading Flux transformer on {train_device}...")
    from diffusers import FluxTransformer2DModel
    transformer = FluxTransformer2DModel.from_pretrained(
        args.model_name, subfolder="transformer", torch_dtype=torch.bfloat16, cache_dir=args.cache_dir
    )

    # Check guidance
    has_guidance = getattr(transformer.config, "guidance_embeds", False)
    print(f"  Model has guidance_embeds: {has_guidance}")

    # LoRA - comprehensive target modules for Flux MMDiT
    lora_target_modules = [
        "attn.to_q", "attn.to_k", "attn.to_v", "attn.to_out.0",
        "attn.add_k_proj", "attn.add_q_proj", "attn.add_v_proj", "attn.to_add_out",
        "ff.net.0.proj", "ff.net.2",
        "ff_context.net.0.proj", "ff_context.net.2",
    ]

    lora_config = LoraConfig(
        r=args.lora_rank,
        lora_alpha=args.lora_alpha,
        target_modules=lora_target_modules,
        lora_dropout=0.0,
    )
    transformer = get_peft_model(transformer, lora_config)

    # Load checkpoint weights if resuming
    if resume_path:
        adapter_path = resume_path / "adapter_model.safetensors"
        if adapter_path.exists():
            import safetensors.torch
            state_dict = safetensors.torch.load_file(str(adapter_path))
            set_peft_model_state_dict(transformer, state_dict)
            print(f"  Loaded LoRA weights from checkpoint")
        else:
            adapter_bin = resume_path / "adapter_model.bin"
            if adapter_bin.exists():
                state_dict = torch.load(str(adapter_bin), map_location="cpu")
                set_peft_model_state_dict(transformer, state_dict)
                print(f"  Loaded LoRA weights from checkpoint")

    transformer.to(train_device)
    transformer.print_trainable_parameters()
    transformer.train()

    # Optimizer + scheduler
    trainable_params = [p for p in transformer.parameters() if p.requires_grad]
    optimizer = torch.optim.AdamW(trainable_params, lr=args.learning_rate, weight_decay=0.01, betas=(0.9, 0.999))

    from diffusers.optimization import get_scheduler
    lr_scheduler = get_scheduler(
        args.lr_scheduler,
        optimizer=optimizer,
        num_warmup_steps=args.lr_warmup_steps,
        num_training_steps=args.max_train_steps,
    )

    # Restore optimizer + scheduler state if resuming
    if resume_step > 0 and resume_path:
        training_state_path = resume_path / "training_state.pt"
        if training_state_path.exists():
            state = torch.load(str(training_state_path), map_location="cpu")
            optimizer.load_state_dict(state["optimizer"])
            lr_scheduler.load_state_dict(state["lr_scheduler"])
            print(f"  Restored optimizer + scheduler state from checkpoint")
        else:
            print(f"  No training_state.pt found, fast-forwarding scheduler...")
            for _ in range(resume_step):
                lr_scheduler.step()

    # Dataset
    print(f"  Loading dataset from {args.data_dir}")
    train_dataset, num_shards = create_webdataset(args.data_dir, args.resolution, args.batch_size)
    train_dataloader = torch.utils.data.DataLoader(
        train_dataset, batch_size=None, num_workers=2, prefetch_factor=4
    )

    # Sample prompts for monitoring
    sample_prompts = [
        "a beautiful mountain landscape at sunset, 4k, highly detailed",
        "a cute cat sitting on a windowsill, natural lighting",
        "a futuristic city skyline at night with neon lights",
        "portrait of a woman with flowers in her hair, oil painting style",
    ]

    # Training loop
    global_step = resume_step
    accum_loss = 0.0
    accum_grad_norm = 0.0
    accum_count = 0
    log_interval = 50
    t0 = time.time()

    print(f"\n  === Training Config ===")
    print(f"    Model: {args.model_name}")
    print(f"    LoRA rank: {args.lora_rank}, alpha: {args.lora_alpha}, scaling: {args.lora_alpha/args.lora_rank:.2f}")
    print(f"    Batch size: {args.batch_size}, Grad accum: {args.gradient_accumulation}")
    print(f"    Effective batch: {args.batch_size * args.gradient_accumulation}")
    print(f"    LR: {args.learning_rate}, Scheduler: {args.lr_scheduler}, Warmup: {args.lr_warmup_steps}")
    print(f"    Weighting: {args.weighting_scheme}")
    print(f"    Guidance: {args.guidance_scale if has_guidance else 'N/A (Schnell)'}")
    print(f"    Encode: {encode_device}, Train: {train_device}")
    print(f"    Save every {args.save_steps} steps, Sample every {args.sample_steps} steps")
    print(f"    Starting from step {global_step}")
    print(f"  ========================\n")

    optimizer.zero_grad()

    while global_step < args.max_train_steps:
        for batch in train_dataloader:
            if global_step >= args.max_train_steps:
                break

            images = batch["image"].to(encode_device, dtype=torch.bfloat16)
            captions = batch["caption"]
            bs = images.shape[0]

            # === Encode on encode_device ===
            with torch.no_grad():
                # VAE encode
                latents = vae.encode(images).latent_dist.sample()
                latents = (latents - vae_shift) * vae_scale
                # latents shape: [B, 16, H/8, W/8]

                _, num_channels, latent_h, latent_w = latents.shape

                # Text encode - CLIP (pooled)
                text_ids = tokenizer(
                    captions, padding="max_length", max_length=77,
                    truncation=True, return_tensors="pt"
                ).input_ids.to(encode_device)
                pooled_prompt_embeds = text_encoder(text_ids, output_hidden_states=False).pooler_output

                # Text encode - T5 (sequence)
                text_ids_2 = tokenizer_2(
                    captions, padding="max_length", max_length=512,
                    truncation=True, return_tensors="pt"
                ).input_ids.to(encode_device)
                encoder_hidden_states = text_encoder_2(text_ids_2)[0]

            # === Move to train device ===
            latents = latents.to(train_device)
            pooled_prompt_embeds = pooled_prompt_embeds.to(train_device)
            encoder_hidden_states = encoder_hidden_states.to(train_device)

            # === Flow matching setup ===
            noise = torch.randn_like(latents)

            # Sample timesteps using density function
            u = compute_density_for_timestep_sampling(
                args.weighting_scheme, bs, args.logit_mean, args.logit_std
            )
            # u is in [0, 1], use as sigmas directly (linear schedule)
            sigmas = u.to(device=train_device, dtype=torch.bfloat16)
            sigmas_expand = sigmas.view(-1, 1, 1, 1)

            # Noisy latents: linear interpolation
            noisy_latents = (1.0 - sigmas_expand) * latents + sigmas_expand * noise

            # Target: velocity = noise - clean
            target = noise - latents

            # === Pack latents for transformer ===
            packed_noisy = pack_latents(noisy_latents, bs, num_channels, latent_h, latent_w)
            packed_target = pack_latents(target, bs, num_channels, latent_h, latent_w)

            # === Prepare positional IDs ===
            # img_ids: spatial positions for packed patches
            # packed dims are latent_h//2, latent_w//2
            img_ids = prepare_latent_image_ids(
                latent_h // 2, latent_w // 2, train_device, torch.bfloat16
            )

            # txt_ids: zeros for text tokens
            txt_ids = torch.zeros(encoder_hidden_states.shape[1], 3, device=train_device, dtype=torch.bfloat16)

            # === Timesteps for transformer (divide by 1000) ===
            timesteps = (sigmas * 1000.0)

            # === Guidance ===
            guidance = None
            if has_guidance:
                guidance = torch.full((bs,), args.guidance_scale, device=train_device, dtype=torch.bfloat16)

            # === Forward pass ===
            with torch.amp.autocast("cuda", dtype=torch.bfloat16):
                model_pred = transformer(
                    hidden_states=packed_noisy,
                    timestep=timesteps / 1000,
                    guidance=guidance,
                    encoder_hidden_states=encoder_hidden_states,
                    pooled_projections=pooled_prompt_embeds,
                    img_ids=img_ids,
                    txt_ids=txt_ids,
                    return_dict=False,
                )[0]

            # === Loss computation in fp32 ===
            weighting = compute_loss_weighting(args.weighting_scheme, sigmas)
            # weighting shape: [B], need to expand for sequence dim
            weighting = weighting.view(-1, 1, 1).to(model_pred.device)

            loss = torch.mean(
                (weighting * (model_pred.float() - packed_target.float()) ** 2).reshape(bs, -1),
                dim=1,
            ).mean()

            # NaN check
            if torch.isnan(loss) or torch.isinf(loss):
                print(f"  WARNING: Invalid loss at step {global_step}, skipping batch", flush=True)
                optimizer.zero_grad()
                accum_count += 1
                continue

            scaled_loss = loss / args.gradient_accumulation
            scaled_loss.backward()

            accum_loss += loss.item()
            accum_count += 1

            # === Optimizer step ===
            if accum_count % args.gradient_accumulation == 0:
                grad_norm = torch.nn.utils.clip_grad_norm_(trainable_params, args.max_grad_norm)
                accum_grad_norm += grad_norm.item()

                optimizer.step()
                lr_scheduler.step()
                optimizer.zero_grad()
                global_step += 1

                # === Logging ===
                if global_step % log_interval == 0:
                    elapsed = time.time() - t0
                    steps_done = global_step - resume_step
                    steps_per_sec = steps_done / elapsed if elapsed > 0 else 0
                    avg_loss = accum_loss / (log_interval * args.gradient_accumulation)
                    avg_grad = accum_grad_norm / log_interval
                    cur_lr = lr_scheduler.get_last_lr()[0]
                    print(
                        f"  Step {global_step:6d} | "
                        f"Loss: {avg_loss:.4f} | "
                        f"GradNorm: {avg_grad:.3f} | "
                        f"LR: {cur_lr:.2e} | "
                        f"Speed: {steps_per_sec:.2f} st/s | "
                        f"Elapsed: {elapsed/3600:.1f}h",
                        flush=True,
                    )
                    accum_loss = 0.0
                    accum_grad_norm = 0.0

                # === Save checkpoint ===
                if global_step % args.save_steps == 0:
                    save_path = args.output_dir / f"checkpoint-{global_step}"
                    save_path.mkdir(parents=True, exist_ok=True)
                    transformer.save_pretrained(save_path)
                    # Save optimizer state for proper resume
                    torch.save({
                        "optimizer": optimizer.state_dict(),
                        "lr_scheduler": lr_scheduler.state_dict(),
                        "global_step": global_step,
                    }, save_path / "training_state.pt")
                    print(f"  Saved checkpoint: {save_path}", flush=True)

                    # Cleanup old checkpoints (keep last 3)
                    all_ckpts = sorted(
                        [d for d in args.output_dir.iterdir() if d.is_dir() and d.name.startswith("checkpoint-")],
                        key=lambda p: int(p.name.split("-")[1]),
                    )
                    if len(all_ckpts) > 3:
                        for old_ckpt in all_ckpts[:-3]:
                            import shutil
                            shutil.rmtree(old_ckpt)
                            print(f"  Removed old checkpoint: {old_ckpt.name}")

                # === Generate samples ===
                if global_step % args.sample_steps == 0:
                    print(f"  Generating samples at step {global_step}...")
                    generate_samples(
                        transformer=transformer,
                        vae=vae,
                        text_encoder=text_encoder,
                        text_encoder_2=text_encoder_2,
                        tokenizer=tokenizer,
                        tokenizer_2=tokenizer_2,
                        prompts=sample_prompts,
                        output_dir=args.output_dir,
                        global_step=global_step,
                        encode_device=encode_device,
                        train_device=train_device,
                        num_inference_steps=4,
                        guidance_scale=0.0,
                    )

    # Final save
    final_path = args.output_dir / "final"
    final_path.mkdir(parents=True, exist_ok=True)
    transformer.save_pretrained(final_path)
    print(f"  Training complete! Saved to {final_path}")


if __name__ == "__main__":
    main()