Fix train_flux_lora.py: add cache-dir, resume, 2GPU split, infinite train

scripts/training/train_flux_lora.py

@@ -1,12 +1,15 @@
 """
-Fine-tune Flux model using LoRA on downloaded COYO dataset.
-Split approach: VAE+text encoders on cuda:0, transformer on cuda:1.
+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.
 """
 import argparse
 import gc
+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
@@ -29,27 +32,32 @@ def collate_batch(samples):
 
 
 def create_webdataset(data_dir, resolution=1024, batch_size=1):
+    import io
     transform = get_train_transforms(resolution)
 
     def preprocess(sample):
-        image = sample["jpg"]
-        if isinstance(image, bytes):
-            import io
-            image = Image.open(io.BytesIO(image)).convert("RGB")
-        caption = sample["txt"]
-        if isinstance(caption, bytes):
-            caption = caption.decode("utf-8")
-        return {"image": transform(image), "caption": caption}
+        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)
         .shuffle(1000)
         .decode("pil")
         .map(preprocess)
+        .select(lambda x: x is not None)
         .batched(batch_size, collation_fn=collate_batch)
     )
     return dataset
@@ -62,25 +70,40 @@ def pack_latents(latents):
     return latents
 
 
+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
+
+
 def main():
-    parser = argparse.ArgumentParser(description="Fine-tune Flux with LoRA")
+    parser = argparse.ArgumentParser()
     parser.add_argument("--model-name", default="black-forest-labs/FLUX.1-schnell")
-    parser.add_argument("--data-dir", type=Path, default=Path("/home/adminuser/chungcat/data/processed/flux_train/shards"))
-    parser.add_argument("--output-dir", type=Path, default=Path("/home/adminuser/chungcat/checkpoints/flux_lora"))
+    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="cosine")
-    parser.add_argument("--lr-warmup-steps", type=int, default=1000)
-    parser.add_argument("--max-train-steps", type=int, default=100000)
-    parser.add_argument("--save-steps", type=int, default=5000)
+    parser.add_argument("--lr-warmup-steps", type=int, default=500)
+    parser.add_argument("--max-train-steps", type=int, default=999999999)
+    parser.add_argument("--save-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("--seed", type=int, default=42)
-    parser.add_argument("--gradient-checkpointing", action="store_true", default=True)
     parser.add_argument("--encode-device", default="cuda:0")
     parser.add_argument("--train-device", default="cuda:1")
+    parser.add_argument("--resume-from-checkpoint", default="auto")
     args = parser.parse_args()
 
     args.output_dir.mkdir(parents=True, exist_ok=True)
@@ -89,45 +112,56 @@ def main():
     encode_device = torch.device(args.encode_device)
     train_device = torch.device(args.train_device)
 
-    # --- Load tokenizers ---
-    print("Loading tokenizers...")
+    # 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")
+        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")
-    tokenizer_2 = T5TokenizerFast.from_pretrained(args.model_name, subfolder="tokenizer_2")
+    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}...")
+    # 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
+        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
+        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
+        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
 
-    # --- Load transformer on train_device ---
-    print(f"Loading Flux transformer on {train_device}...")
+    # 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
+        args.model_name, subfolder="transformer", torch_dtype=torch.bfloat16, cache_dir=args.cache_dir
     )
 
-    if args.gradient_checkpointing:
-        transformer.enable_gradient_checkpointing()
-
+    # LoRA
     lora_config = LoraConfig(
         r=args.lora_rank,
         lora_alpha=args.lora_alpha,
@@ -135,16 +169,30 @@ def main():
         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
+            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 ---
-    optimizer = torch.optim.AdamW(
-        [p for p in transformer.parameters() if p.requires_grad],
-        lr=args.learning_rate,
-        weight_decay=0.01,
-    )
+    # 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)
 
     from diffusers.optimization import get_scheduler
     lr_scheduler = get_scheduler(
@@ -154,22 +202,28 @@ def main():
         num_training_steps=args.max_train_steps,
     )
 
-    # --- Dataset ---
-    print(f"Loading dataset from {args.data_dir}")
+    # Fast-forward scheduler if resuming
+    if resume_step > 0:
+        for _ in range(resume_step):
+            lr_scheduler.step()
+
+    # Dataset
+    print(f"  Loading dataset from {args.data_dir}")
     train_dataset = create_webdataset(args.data_dir, args.resolution, args.batch_size)
     train_dataloader = torch.utils.data.DataLoader(
         train_dataset, batch_size=None, num_workers=4, pin_memory=True
     )
 
-    # --- Training loop ---
-    global_step = 0
+    # Training loop
+    global_step = resume_step
     accum_loss = 0.0
-    print(f"\nStarting training for {args.max_train_steps} steps...")
-    print(f"  Batch size: {args.batch_size}, Grad accum: {args.gradient_accumulation}")
-    print(f"  Effective batch: {args.batch_size * args.gradient_accumulation}")
-    print(f"  Encode device: {encode_device}, Train device: {train_device}")
+    t0 = time.time()
 
-    scaler = None  # bf16 doesn't need GradScaler
+    print(f"\n  Starting training from step {global_step}...")
+    print(f"    Batch size: {args.batch_size}, Grad accum: {args.gradient_accumulation}")
+    print(f"    Effective batch: {args.batch_size * args.gradient_accumulation}")
+    print(f"    Encode: {encode_device}, Train: {train_device}")
+    print(f"    Save every {args.save_steps} steps")
 
     while global_step < args.max_train_steps:
         for batch in train_dataloader:
@@ -210,61 +264,66 @@ def main():
             noisy_packed = pack_latents(noisy_latents)
             target = pack_latents(noise - latents)
 
-            timesteps = (t * 1000).to(dtype=torch.bfloat16)
+            timesteps = t
 
             b, seq_len, _ = noisy_packed.shape
             h_patches = w_patches = int(seq_len ** 0.5)
-            img_ids = torch.zeros(b, seq_len, 3, device=train_device, dtype=torch.bfloat16)
-            img_ids[:, :, 1] = torch.arange(h_patches, device=train_device).repeat_interleave(w_patches).unsqueeze(0).expand(b, -1).to(torch.bfloat16)
-            img_ids[:, :, 2] = torch.arange(w_patches, device=train_device).repeat(h_patches).unsqueeze(0).expand(b, -1).to(torch.bfloat16)
+            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)
 
-            txt_ids = torch.zeros(b, encoder_hidden_states.shape[1], 3, device=train_device, dtype=torch.bfloat16)
+            txt_ids = torch.zeros(encoder_hidden_states.shape[1], 3, device=train_device, dtype=torch.bfloat16)
 
             # Forward
-            with torch.amp.autocast("cuda", dtype=torch.bfloat16):
-                model_pred = transformer(
-                    hidden_states=noisy_packed,
-                    timestep=timesteps / 1000,
-                    encoder_hidden_states=encoder_hidden_states,
-                    pooled_projections=pooled_prompt_embeds,
-                    img_ids=img_ids,
-                    txt_ids=txt_ids,
-                    return_dict=False,
-                )[0]
-
-                loss = torch.nn.functional.mse_loss(model_pred, target, reduction="mean")
-                loss = loss / args.gradient_accumulation
-
+            model_pred = transformer(
+                hidden_states=noisy_packed,
+                timestep=timesteps,
+                encoder_hidden_states=encoder_hidden_states,
+                pooled_projections=pooled_prompt_embeds,
+                img_ids=img_ids,
+                txt_ids=txt_ids,
+                return_dict=False,
+            )[0]
+
+            loss = F.mse_loss(model_pred.float(), target.float())
+            loss = loss / args.gradient_accumulation
             loss.backward()
             accum_loss += loss.item()
 
-            if (global_step + 1) % args.gradient_accumulation == 0 or True:
-                # Check if we should step
-                step_count = (global_step + 1) % args.gradient_accumulation
-                if step_count == 0:
-                    torch.nn.utils.clip_grad_norm_(
-                        [p for p in transformer.parameters() if p.requires_grad], 1.0
-                    )
-                    optimizer.step()
-                    lr_scheduler.step()
-                    optimizer.zero_grad()
+            if (global_step + 1) % args.gradient_accumulation == 0:
+                torch.nn.utils.clip_grad_norm_(trainable_params, 1.0)
+                optimizer.step()
+                lr_scheduler.step()
+                optimizer.zero_grad()
 
             global_step += 1
 
-            if global_step % 100 == 0:
-                avg_loss = accum_loss / 100 * args.gradient_accumulation
-                print(f"Step {global_step}/{args.max_train_steps}, Loss: {avg_loss:.4f}, LR: {lr_scheduler.get_last_lr()[0]:.2e}")
+            if global_step % 50 == 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
+                print(
+                    f"  Step {global_step} | "
+                    f"Loss: {avg_loss:.4f} | "
+                    f"LR: {lr_scheduler.get_last_lr()[0]:.2e} | "
+                    f"Speed: {steps_per_sec:.2f} it/s | "
+                    f"Elapsed: {elapsed/3600:.1f}h",
+                    flush=True,
+                )
                 accum_loss = 0.0
 
             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)
-                print(f"Saved checkpoint to {save_path}")
+                print(f"  Saved checkpoint: {save_path}", flush=True)
 
-    # Save final
+    # 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! Final model saved to {final_path}")
+    print(f"  Training complete! Saved to {final_path}")
 
 
 if __name__ == "__main__":