Upload folder using huggingface_hub

scripts/training/train_flux_lora_ddp.py

@@ -0,0 +1,458 @@
+"""
+Flux LoRA DDP Training Script
+- 2 GPU DDP via accelerate
+- bf16 mixed precision
+- Gradient checkpointing
+- WebDataset loading
+- Checkpoint every 1000 steps with auto-upload to HF
+- Auto-resume from latest checkpoint
+"""
+
+import os
+import sys
+import time
+import math
+import torch
+import torch.nn.functional as F
+from pathlib import Path
+from torch.utils.data import DataLoader
+
+import webdataset as wds
+from accelerate import Accelerator
+from accelerate.utils import set_seed
+from diffusers import FluxPipeline, FlowMatchEulerDiscreteScheduler
+from diffusers.training_utils import compute_density_for_timestep_sampling
+from peft import LoraConfig, get_peft_model
+from transformers import CLIPTextModel, CLIPTokenizer, T5EncoderModel, T5TokenizerFast
+from huggingface_hub import HfApi, upload_folder
+from torchvision import transforms
+from PIL import Image
+import io
+
+
+def get_args():
+    import argparse
+    p = argparse.ArgumentParser()
+    p.add_argument("--model-name", default="black-forest-labs/FLUX.1-dev")
+    p.add_argument("--data-dir", required=True)
+    p.add_argument("--output-dir", required=True)
+    p.add_argument("--batch-size", type=int, default=1)
+    p.add_argument("--gradient-accumulation", type=int, default=4)
+    p.add_argument("--learning-rate", type=float, default=1e-4)
+    p.add_argument("--lr-warmup-steps", type=int, default=100)
+    p.add_argument("--max-train-steps", type=int, default=100000)
+    p.add_argument("--save-steps", type=int, default=1000)
+    p.add_argument("--sample-steps", type=int, default=1000)
+    p.add_argument("--lora-rank", type=int, default=128)
+    p.add_argument("--lora-alpha", type=int, default=64)
+    p.add_argument("--max-grad-norm", type=float, default=1.0)
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--resolution", type=int, default=1024)
+    p.add_argument("--hf-user", default="memoryai")
+    p.add_argument("--hf-repo", default="4k-image-model-checkpoints")
+    return p.parse_args()
+
+
+def create_webdataset(data_dir, resolution, tokenizer, tokenizer_2):
+    transform = transforms.Compose([
+        transforms.Resize(resolution, interpolation=transforms.InterpolationMode.LANCZOS),
+        transforms.CenterCrop(resolution),
+        transforms.ToTensor(),
+        transforms.Normalize([0.5], [0.5]),
+    ])
+
+    def process_sample(sample):
+        try:
+            image = sample.get("jpg") or sample.get("png") or sample.get("jpeg")
+            if image is None:
+                return None
+            if not isinstance(image, Image.Image):
+                image = Image.open(io.BytesIO(image)).convert("RGB")
+            else:
+                image = image.convert("RGB")
+            image = transform(image)
+            caption = sample.get("txt", "")
+            if isinstance(caption, bytes):
+                caption = caption.decode("utf-8")
+
+            tokens_1 = tokenizer(
+                caption, max_length=77, padding="max_length",
+                truncation=True, return_tensors="pt"
+            )
+            tokens_2 = tokenizer_2(
+                caption, max_length=512, padding="max_length",
+                truncation=True, return_tensors="pt"
+            )
+
+            return {
+                "pixel_values": image,
+                "input_ids_1": tokens_1.input_ids.squeeze(0),
+                "attention_mask_1": tokens_1.attention_mask.squeeze(0),
+                "input_ids_2": tokens_2.input_ids.squeeze(0),
+                "attention_mask_2": tokens_2.attention_mask.squeeze(0),
+            }
+        except Exception:
+            return None
+
+    shards = sorted([str(p) for p in Path(data_dir).glob("*.tar")])
+    if not shards:
+        raise ValueError(f"No .tar shards found in {data_dir}")
+
+    dataset = (
+        wds.WebDataset(shards, shardshuffle=1000, nodesplitter=wds.split_by_node, empty_check=False)
+        .decode("pil")
+        .shuffle(1000)
+        .map(process_sample)
+        .select(lambda x: x is not None)
+        .batched(1, collation_fn=lambda batch: {
+            "pixel_values": torch.stack([b["pixel_values"] for b in batch]),
+            "input_ids_1": torch.stack([b["input_ids_1"] for b in batch]),
+            "attention_mask_1": torch.stack([b["attention_mask_1"] for b in batch]),
+            "input_ids_2": torch.stack([b["input_ids_2"] for b in batch]),
+            "attention_mask_2": torch.stack([b["attention_mask_2"] for b in batch]),
+        })
+    )
+    return dataset
+
+
+def find_latest_checkpoint(output_dir):
+    output_path = Path(output_dir)
+    if not output_path.exists():
+        return None, 0
+
+    checkpoints = sorted(
+        [d for d in output_path.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:
+        latest = checkpoints[-1]
+        state_file = latest / "training_state.pt"
+        if state_file.exists():
+            state = torch.load(state_file, map_location="cpu")
+            return latest, state.get("global_step", 0)
+
+    return None, 0
+
+
+def upload_checkpoint(output_dir, checkpoint_name, hf_user, hf_repo):
+    try:
+        repo_id = f"{hf_user}/{hf_repo}"
+        api = HfApi()
+        try:
+            api.repo_info(repo_id=repo_id, repo_type="model")
+        except Exception:
+            api.create_repo(repo_id=repo_id, repo_type="model", private=True)
+
+        ckpt_path = Path(output_dir) / checkpoint_name
+        if ckpt_path.exists():
+            path_in_repo = f"flux_lora_4k/{checkpoint_name}"
+            upload_folder(
+                folder_path=str(ckpt_path),
+                repo_id=repo_id,
+                path_in_repo=path_in_repo,
+                repo_type="model",
+            )
+            print(f"  Uploaded {checkpoint_name} -> {repo_id}/{path_in_repo}")
+
+        samples_dir = Path(output_dir) / "samples"
+        if samples_dir.exists() and any(samples_dir.glob("*.png")):
+            upload_folder(
+                folder_path=str(samples_dir),
+                repo_id=repo_id,
+                path_in_repo="flux_lora_4k/samples",
+                repo_type="model",
+            )
+    except Exception as e:
+        print(f"  Upload failed (non-fatal): {e}")
+
+
+def generate_samples(accelerator, pipe, output_dir, step, prompts=None):
+    if not accelerator.is_main_process:
+        return
+
+    if prompts is None:
+        prompts = [
+            "A stunning 4K photograph of a mountain landscape at golden hour",
+            "A detailed close-up of a butterfly on a flower, 4K ultra HD",
+            "A modern city skyline at night with reflections, high resolution",
+            "A portrait of an elderly craftsman in his workshop, natural lighting",
+        ]
+
+    samples_dir = Path(output_dir) / "samples"
+    samples_dir.mkdir(exist_ok=True)
+
+    try:
+        pipe.to(accelerator.device)
+        with torch.no_grad():
+            for i, prompt in enumerate(prompts):
+                image = pipe(
+                    prompt=prompt,
+                    num_inference_steps=20,
+                    guidance_scale=3.5,
+                    height=1024,
+                    width=1024,
+                ).images[0]
+                image.save(samples_dir / f"step_{step:06d}_{i}.png")
+        print(f"  Samples saved at step {step}")
+    except Exception as e:
+        print(f"  Sample generation failed (non-fatal): {e}")
+
+
+def main():
+    args = get_args()
+    set_seed(args.seed)
+
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation,
+        mixed_precision="bf16",
+        log_with=None,
+    )
+
+    if accelerator.is_main_process:
+        print(f"  Devices: {accelerator.num_processes}")
+        print(f"  Batch size (per device): {args.batch_size}")
+        print(f"  Gradient accumulation: {args.gradient_accumulation}")
+        print(f"  Effective batch size: {args.batch_size * args.gradient_accumulation * accelerator.num_processes}")
+        print(f"  LoRA rank: {args.lora_rank}, alpha: {args.lora_alpha}")
+        print(f"  Max steps: {args.max_train_steps}")
+        print(f"  Save every: {args.save_steps} steps")
+
+    # Load tokenizers
+    tokenizer = CLIPTokenizer.from_pretrained(args.model_name, subfolder="tokenizer")
+    tokenizer_2 = T5TokenizerFast.from_pretrained(args.model_name, subfolder="tokenizer_2")
+
+    # Load text encoders
+    text_encoder = CLIPTextModel.from_pretrained(
+        args.model_name, subfolder="text_encoder", torch_dtype=torch.bfloat16
+    )
+    text_encoder_2 = T5EncoderModel.from_pretrained(
+        args.model_name, subfolder="text_encoder_2", torch_dtype=torch.bfloat16
+    )
+    text_encoder.requires_grad_(False)
+    text_encoder_2.requires_grad_(False)
+
+    # Load pipeline for VAE and transformer
+    pipe = FluxPipeline.from_pretrained(args.model_name, torch_dtype=torch.bfloat16)
+    vae = pipe.vae
+    transformer = pipe.transformer
+    noise_scheduler = pipe.scheduler
+
+    vae.requires_grad_(False)
+
+    # Apply LoRA to transformer
+    lora_config = LoraConfig(
+        r=args.lora_rank,
+        lora_alpha=args.lora_alpha,
+        target_modules=["to_q", "to_k", "to_v", "to_out.0", "proj_in", "proj_out",
+                        "ff.net.0.proj", "ff.net.2"],
+        lora_dropout=0.0,
+    )
+    transformer = get_peft_model(transformer, lora_config)
+    transformer.enable_gradient_checkpointing()
+
+    if accelerator.is_main_process:
+        trainable = sum(p.numel() for p in transformer.parameters() if p.requires_grad)
+        total = sum(p.numel() for p in transformer.parameters())
+        print(f"  Trainable params: {trainable:,} / {total:,} ({100*trainable/total:.2f}%)")
+
+    # Optimizer
+    optimizer = torch.optim.AdamW(
+        [p for p in transformer.parameters() if p.requires_grad],
+        lr=args.learning_rate,
+        betas=(0.9, 0.999),
+        weight_decay=0.01,
+        eps=1e-8,
+    )
+
+    # Dataset
+    dataset = create_webdataset(args.data_dir, args.resolution, tokenizer, tokenizer_2)
+
+    dataloader = DataLoader(
+        dataset, batch_size=None, num_workers=2, pin_memory=True,
+        prefetch_factor=2,
+    )
+
+    # LR Scheduler
+    from torch.optim.lr_scheduler import LambdaLR
+    def lr_lambda(step):
+        if step < args.lr_warmup_steps:
+            return step / max(1, args.lr_warmup_steps)
+        return 1.0
+    lr_scheduler = LambdaLR(optimizer, lr_lambda)
+
+    # Prepare with accelerate (dataloader excluded - WebDataset handles DDP splitting)
+    transformer, optimizer, lr_scheduler = accelerator.prepare(
+        transformer, optimizer, lr_scheduler
+    )
+
+    # Move frozen models to device
+    vae.to(accelerator.device, dtype=torch.bfloat16)
+    text_encoder.to(accelerator.device)
+    text_encoder_2.to(accelerator.device)
+
+    # Resume from checkpoint
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    resume_ckpt, global_step = find_latest_checkpoint(args.output_dir)
+
+    if resume_ckpt is not None:
+        if accelerator.is_main_process:
+            print(f"  Resuming from {resume_ckpt.name} (step {global_step})")
+        state = torch.load(resume_ckpt / "training_state.pt", map_location="cpu")
+        optimizer.load_state_dict(state["optimizer"])
+        lr_scheduler.load_state_dict(state["lr_scheduler"])
+        # Load LoRA weights
+        from peft import set_peft_model_state_dict
+        lora_state = torch.load(resume_ckpt / "lora_weights.pt", map_location="cpu")
+        set_peft_model_state_dict(accelerator.unwrap_model(transformer), lora_state)
+    else:
+        if accelerator.is_main_process:
+            print("  Starting from scratch")
+
+    # Training loop
+    if accelerator.is_main_process:
+        print(f"\n  Training started at step {global_step}...")
+
+    transformer.train()
+    step_times = []
+    data_iter = iter(dataloader)
+
+    while global_step < args.max_train_steps:
+        step_start = time.time()
+
+        try:
+            batch = next(data_iter)
+        except (StopIteration, Exception):
+            data_iter = iter(dataloader)
+            batch = next(data_iter)
+
+        with accelerator.accumulate(transformer):
+            pixel_values = batch["pixel_values"].to(dtype=torch.bfloat16)
+
+            # Encode images
+            with torch.no_grad():
+                latents = vae.encode(pixel_values).latent_dist.sample()
+                latents = (latents - vae.config.shift_factor) * vae.config.scaling_factor
+
+                # Pack latents for Flux
+                batch_size, channels, height, width = latents.shape
+                latents = latents.reshape(batch_size, channels, height // 2, 2, width // 2, 2)
+                latents = latents.permute(0, 2, 4, 1, 3, 5).reshape(batch_size, (height // 2) * (width // 2), channels * 4)
+
+                # Text encoding
+                text_output_1 = text_encoder(
+                    batch["input_ids_1"], attention_mask=batch["attention_mask_1"]
+                )
+                pooled_prompt_embeds = text_output_1.pooler_output
+
+                text_output_2 = text_encoder_2(
+                    batch["input_ids_2"], attention_mask=batch["attention_mask_2"]
+                )
+                prompt_embeds = text_output_2.last_hidden_state
+
+            # Sample noise and timesteps
+            noise = torch.randn_like(latents)
+            timesteps = torch.rand(batch_size, device=latents.device, dtype=torch.bfloat16)
+
+            # Flow matching: interpolate between noise and latents
+            sigmas = timesteps.view(-1, 1, 1)
+            noisy_latents = (1 - sigmas) * latents + sigmas * noise
+
+            # Predict velocity
+            model_pred = transformer(
+                hidden_states=noisy_latents,
+                timestep=timesteps * 1000,
+                encoder_hidden_states=prompt_embeds,
+                pooled_projections=pooled_prompt_embeds,
+                return_dict=False,
+            )[0]
+
+            # Flow matching loss: predict (noise - latents)
+            target = noise - latents
+            loss = F.mse_loss(model_pred, target, reduction="mean")
+
+            accelerator.backward(loss)
+            if accelerator.sync_gradients:
+                accelerator.clip_grad_norm_(transformer.parameters(), args.max_grad_norm)
+            optimizer.step()
+            lr_scheduler.step()
+            optimizer.zero_grad()
+
+        if accelerator.sync_gradients:
+            global_step += 1
+            step_time = time.time() - step_start
+            step_times.append(step_time)
+
+            # Logging
+            if global_step % 50 == 0 and accelerator.is_main_process:
+                avg_time = sum(step_times[-50:]) / len(step_times[-50:])
+                steps_remaining = args.max_train_steps - global_step
+                eta_hours = (steps_remaining * avg_time) / 3600
+                print(
+                    f"  Step {global_step}/{args.max_train_steps} | "
+                    f"Loss: {loss.item():.4f} | "
+                    f"LR: {lr_scheduler.get_last_lr()[0]:.2e} | "
+                    f"Time/step: {avg_time:.2f}s | "
+                    f"ETA: {eta_hours:.1f}h"
+                )
+
+            # Save checkpoint
+            if global_step % args.save_steps == 0:
+                if accelerator.is_main_process:
+                    ckpt_name = f"checkpoint-{global_step}"
+                    ckpt_path = output_dir / ckpt_name
+                    ckpt_path.mkdir(exist_ok=True)
+
+                    # Save LoRA weights
+                    from peft import get_peft_model_state_dict
+                    lora_state = get_peft_model_state_dict(accelerator.unwrap_model(transformer))
+                    torch.save(lora_state, ckpt_path / "lora_weights.pt")
+
+                    # Save training state
+                    torch.save({
+                        "global_step": global_step,
+                        "optimizer": optimizer.state_dict(),
+                        "lr_scheduler": lr_scheduler.state_dict(),
+                    }, ckpt_path / "training_state.pt")
+
+                    print(f"  Checkpoint saved: {ckpt_name}")
+
+                    # Upload to HF
+                    upload_checkpoint(
+                        args.output_dir, ckpt_name, args.hf_user, args.hf_repo
+                    )
+
+                    # Clean old checkpoints (keep last 3)
+                    all_ckpts = 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]),
+                    )
+                    for old_ckpt in all_ckpts[:-3]:
+                        import shutil
+                        shutil.rmtree(old_ckpt)
+                        print(f"  Removed old: {old_ckpt.name}")
+
+                accelerator.wait_for_everyone()
+
+            # Generate samples
+            if global_step % args.sample_steps == 0:
+                if accelerator.is_main_process:
+                    generate_samples(accelerator, pipe, args.output_dir, global_step)
+
+    # Final save
+    if accelerator.is_main_process:
+        final_path = output_dir / "final"
+        final_path.mkdir(exist_ok=True)
+        from peft import get_peft_model_state_dict
+        lora_state = get_peft_model_state_dict(accelerator.unwrap_model(transformer))
+        torch.save(lora_state, final_path / "lora_weights.pt")
+        torch.save({"global_step": global_step}, final_path / "training_state.pt")
+        print(f"\n  Training complete! Final model saved at step {global_step}")
+        upload_checkpoint(args.output_dir, "final", args.hf_user, args.hf_repo)
+
+    accelerator.end_training()
+
+
+if __name__ == "__main__":
+    main()