Upload scripts/training/train_flux_lora.py with huggingface_hub

scripts/training/train_flux_lora.py

@@ -1,10 +1,12 @@
 """
 Fine-tune Flux with LoRA - 2 GPU split (encode on GPU0, train on GPU1).
-Reads webdataset shards directly, no precompute needed.
-Supports resume from checkpoint.
+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
 
@@ -13,7 +15,7 @@ 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
+from peft import LoraConfig, get_peft_model, set_peft_model_state_dict
 
 
 def get_train_transforms(resolution=1024):
@@ -32,7 +34,6 @@ def collate_batch(samples):
 
 
 def create_webdataset(data_dir, resolution=1024, batch_size=1):
-    import io
     transform = get_train_transforms(resolution)
 
     def preprocess(sample):
@@ -63,13 +64,50 @@ def create_webdataset(data_dir, resolution=1024, batch_size=1):
     return dataset, len(tar_files)
 
 
-def pack_latents(latents):
-    b, c, h, w = latents.shape
-    latents = latents.reshape(b, c, h // 2, 2, w // 2, 2)
-    latents = latents.permute(0, 2, 4, 1, 3, 5).reshape(b, (h // 2) * (w // 2), c * 4)
+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():
@@ -84,6 +122,53 @@ def find_latest_checkpoint(output_dir):
     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=4, guidance_scale=0.0,
+):
+    from diffusers import FluxPipeline
+    import numpy as np
+
+    output_dir = Path(output_dir) / "samples"
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    transformer.eval()
+
+    try:
+        pipe = FluxPipeline.from_pretrained(
+            "black-forest-labs/FLUX.1-schnell",
+            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(train_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}")
+
+    transformer.train()
+    torch.cuda.empty_cache()
+
+
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--model-name", default="black-forest-labs/FLUX.1-schnell")
@@ -94,16 +179,22 @@ def main():
     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="cosine")
-    parser.add_argument("--lr-warmup-steps", type=int, default=500)
+    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=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)
@@ -112,7 +203,6 @@ def main():
     encode_device = torch.device(args.encode_device)
     train_device = torch.device(args.train_device)
 
-    # Check if only 1 GPU available
     if torch.cuda.device_count() < 2:
         print("  Only 1 GPU, using same device for encode + train")
         encode_device = torch.device("cuda:0")
@@ -153,6 +243,7 @@ def main():
 
     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}...")
@@ -161,18 +252,28 @@ def main():
         args.model_name, subfolder="transformer", torch_dtype=torch.bfloat16, cache_dir=args.cache_dir
     )
 
-    # LoRA
+    # 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=["to_q", "to_k", "to_v", "to_out.0"],
+        target_modules=lora_target_modules,
         lora_dropout=0.0,
     )
     transformer = get_peft_model(transformer, lora_config)
 
     # Load checkpoint weights if resuming
     if resume_path:
-        from peft import set_peft_model_state_dict
         adapter_path = resume_path / "adapter_model.safetensors"
         if adapter_path.exists():
             import safetensors.torch
@@ -186,18 +287,13 @@ def main():
                 set_peft_model_state_dict(transformer, state_dict)
                 print(f"  Loaded LoRA weights from checkpoint")
 
-    # Cast LoRA params to fp32 to prevent NaN in bf16 backward pass
-    for name, p in transformer.named_parameters():
-        if p.requires_grad:
-            p.data = p.data.float()
-
     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)
+    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(
@@ -216,20 +312,37 @@ def main():
     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=0
+        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  Starting training from step {global_step}...")
+    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")
+    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()
 
@@ -240,54 +353,81 @@ def main():
 
             images = batch["image"].to(encode_device, dtype=torch.bfloat16)
             captions = batch["caption"]
+            bs = images.shape[0]
 
-            # Encode on encode_device
+            # === 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=256,
+                    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
+            # === 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
+            # === Flow matching setup ===
             noise = torch.randn_like(latents)
-            t = torch.rand(latents.shape[0], device=train_device, dtype=torch.bfloat16)
-            t_expand = t.view(-1, 1, 1, 1)
-            noisy_latents = (1 - t_expand) * latents + t_expand * noise
 
-            noisy_packed = pack_latents(noisy_latents)
-            target = pack_latents(noise - 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)
 
-            # Flux expects raw timestep 0-1
-            timesteps = t
+            # Noisy latents: linear interpolation
+            noisy_latents = (1.0 - sigmas_expand) * latents + sigmas_expand * noise
 
-            b, seq_len, _ = noisy_packed.shape
-            h_patches = w_patches = int(seq_len ** 0.5)
-            img_ids = torch.zeros(seq_len, 3, device=train_device, dtype=torch.bfloat16)
-            img_ids[:, 1] = torch.arange(h_patches, device=train_device).repeat_interleave(w_patches).to(torch.bfloat16)
-            img_ids[:, 2] = torch.arange(w_patches, device=train_device).repeat(h_patches).to(torch.bfloat16)
+            # 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)
 
-            # Forward with autocast for numerical stability
+            # === 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=noisy_packed,
-                    timestep=timesteps,
+                    hidden_states=packed_noisy,
+                    timestep=timesteps / 1000,
+                    guidance=guidance,
                     encoder_hidden_states=encoder_hidden_states,
                     pooled_projections=pooled_prompt_embeds,
                     img_ids=img_ids,
@@ -295,12 +435,19 @@ def main():
                     return_dict=False,
                 )[0]
 
-            # Compute loss in fp32
-            loss = F.mse_loss(model_pred.float(), target.float())
+            # === 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()
 
-            # Check for NaN and skip batch if needed
-            if torch.isnan(loss):
-                print(f"  WARNING: NaN loss at accum_count={accum_count}, skipping batch", flush=True)
+            # 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
@@ -311,36 +458,79 @@ def main():
             accum_loss += loss.item()
             accum_count += 1
 
+            # === Optimizer step ===
             if accum_count % args.gradient_accumulation == 0:
-                torch.nn.utils.clip_grad_norm_(trainable_params, 1.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
 
-                if global_step % 50 == 0:
+                # === 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 / (50 * args.gradient_accumulation) if accum_loss != 0 else float('nan')
-                    cur_loss = loss.item()
+                    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} | "
-                        f"Loss(avg): {avg_loss:.4f} | "
-                        f"Loss(cur): {cur_loss:.4f} | "
-                        f"LR: {lr_scheduler.get_last_lr()[0]:.2e} | "
-                        f"Speed: {steps_per_sec:.2f} steps/s | "
+                        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)