scripts/training/train_flux_deepspeed.py

"""
Flux LoRA Training - Compatible with both single GPU and DeepSpeed multi-GPU.
Uses pre-computed embeddings for maximum GPU efficiency.
"""
import argparse
import os
import time
from pathlib import Path

import torch
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
from accelerate import Accelerator
from accelerate.utils import set_seed
from diffusers import FluxTransformer2DModel
from diffusers.optimization import get_scheduler
from peft import LoraConfig, get_peft_model


class EmbeddingDataset(Dataset):
    def __init__(self, embedding_dir):
        self.embedding_dir = Path(embedding_dir)
        self.shard_files = sorted(self.embedding_dir.glob("shard-*.pt"))
        if not self.shard_files:
            raise ValueError(f"No shard files found in {embedding_dir}")

        self.shard_lengths = []
        self.cumulative = [0]
        for sf in self.shard_files:
            data = torch.load(sf, map_location="cpu", weights_only=False)
            self.shard_lengths.append(len(data))
            self.cumulative.append(self.cumulative[-1] + len(data))
            del data

        self.total_samples = self.cumulative[-1]
        self._cache_shard_idx = -1
        self._cache_data = None
        print(f"EmbeddingDataset: {self.total_samples} samples in {len(self.shard_files)} shards")

    def __len__(self):
        return self.total_samples

    def _get_shard_and_local_idx(self, idx):
        for i in range(len(self.shard_files)):
            if idx < self.cumulative[i + 1]:
                return i, idx - self.cumulative[i]
        raise IndexError(f"Index {idx} out of range")

    def __getitem__(self, idx):
        shard_idx, local_idx = self._get_shard_and_local_idx(idx)

        if shard_idx != self._cache_shard_idx:
            self._cache_data = torch.load(
                self.shard_files[shard_idx], map_location="cpu", weights_only=False
            )
            self._cache_shard_idx = shard_idx

        sample = self._cache_data[local_idx]
        return {
            "packed_latents": sample["packed_latents"],
            "pooled_prompt_embeds": sample["pooled_prompt_embeds"],
            "encoder_hidden_states": sample["encoder_hidden_states"],
            "img_ids": sample["img_ids"],
            "txt_ids": sample["txt_ids"],
        }


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()
    parser.add_argument("--model-name", default="black-forest-labs/FLUX.1-schnell")
    parser.add_argument("--embedding-dir", type=Path, default=Path("/data0/datasets/processed/flux_train/embeddings"))
    parser.add_argument("--output-dir", type=Path, default=Path("/data0/checkpoints/flux_lora_ds"))
    parser.add_argument("--cache-dir", default="/data0/models")
    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("--max-train-steps", type=int, default=100000)
    parser.add_argument("--save-steps", type=int, default=5000)
    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("--resume-from-checkpoint", default="auto")
    args = parser.parse_args()

    accelerator = Accelerator(
        mixed_precision="bf16",
        gradient_accumulation_steps=args.gradient_accumulation,
        log_with=None,
    )

    set_seed(args.seed)

    if accelerator.is_main_process:
        args.output_dir.mkdir(parents=True, exist_ok=True)
        print(f"Process count: {accelerator.num_processes}")
        print(f"Device: {accelerator.device}")

    # Resume logic
    resume_path = None
    resume_step = 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 transformer
    if accelerator.is_main_process:
        print("Loading Flux Transformer...")
    transformer = FluxTransformer2DModel.from_pretrained(
        args.model_name,
        subfolder="transformer",
        torch_dtype=torch.bfloat16,
        cache_dir=args.cache_dir,
    )

    # LoRA
    lora_config = LoraConfig(
        r=args.lora_rank,
        lora_alpha=args.lora_alpha,
        target_modules=["to_q", "to_k", "to_v", "to_out.0"],
        lora_dropout=0.0,
    )
    transformer = get_peft_model(transformer, lora_config)

    # Load LoRA weights if resuming
    if resume_path:
        from peft import set_peft_model_state_dict
        import safetensors.torch
        adapter_path = resume_path / "adapter_model.safetensors"
        if adapter_path.exists():
            state_dict = safetensors.torch.load_file(str(adapter_path))
            set_peft_model_state_dict(transformer, state_dict)
            print(f"  Loaded LoRA weights from {adapter_path}")
        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 {adapter_bin}")

    # Cast trainable params to fp32 for stable training
    for name, p in transformer.named_parameters():
        if p.requires_grad:
            p.data = p.data.float()

    if accelerator.is_main_process:
        transformer.print_trainable_parameters()

    # Optimizer
    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)

    lr_scheduler = get_scheduler(
        args.lr_scheduler,
        optimizer=optimizer,
        num_warmup_steps=args.lr_warmup_steps,
        num_training_steps=args.max_train_steps,
    )

    # Dataset
    dataset = EmbeddingDataset(args.embedding_dir)
    dataloader = DataLoader(
        dataset,
        batch_size=args.batch_size,
        shuffle=True,
        num_workers=2,
        pin_memory=True,
        drop_last=True,
    )

    # Prepare
    transformer, optimizer, dataloader, lr_scheduler = accelerator.prepare(
        transformer, optimizer, dataloader, lr_scheduler
    )

    # Skip steps if resuming
    global_step = resume_step
    if resume_step > 0:
        steps_to_skip = resume_step * args.gradient_accumulation
        if accelerator.is_main_process:
            print(f"  Skipping {steps_to_skip} dataloader batches...")
        skipped = 0
        skip_dl = iter(dataloader)
        while skipped < steps_to_skip:
            try:
                next(skip_dl)
                skipped += 1
            except StopIteration:
                skip_dl = iter(dataloader)
        del skip_dl

    # Training
    t0 = time.time()

    if accelerator.is_main_process:
        print(f"\nStarting training from step {global_step}...")
        print(f"  Batch size/GPU: {args.batch_size}")
        print(f"  Num GPUs: {accelerator.num_processes}")
        print(f"  Grad accumulation: {args.gradient_accumulation}")
        print(f"  Effective batch: {args.batch_size * accelerator.num_processes * args.gradient_accumulation}")
        print(f"  Max steps: {args.max_train_steps}")
        print(f"  Dataset: {len(dataset)} samples")

    transformer.train()

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

            with accelerator.accumulate(transformer):
                packed_latents = batch["packed_latents"].to(dtype=torch.bfloat16)
                pooled_prompt_embeds = batch["pooled_prompt_embeds"].to(dtype=torch.bfloat16)
                encoder_hidden_states = batch["encoder_hidden_states"].to(dtype=torch.bfloat16)
                img_ids = batch["img_ids"][0]
                txt_ids = batch["txt_ids"][0]

                bs = packed_latents.shape[0]

                noise = torch.randn_like(packed_latents)
                t = torch.rand(bs, device=packed_latents.device, dtype=torch.bfloat16)
                t_expand = t.view(-1, 1, 1)

                noisy_latents = (1 - t_expand) * packed_latents + t_expand * noise
                timesteps = t

                model_pred = transformer(
                    hidden_states=noisy_latents,
                    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]

                target = noise - packed_latents
                loss = F.mse_loss(model_pred.float(), target.float())

                accelerator.backward(loss)

                if accelerator.sync_gradients:
                    accelerator.clip_grad_norm_(trainable_params, 1.0)

                optimizer.step()
                lr_scheduler.step()
                optimizer.zero_grad()

            if accelerator.sync_gradients:
                global_step += 1

                if global_step % 100 == 0 and accelerator.is_main_process:
                    elapsed = time.time() - t0
                    steps_done = global_step - resume_step
                    steps_per_sec = steps_done / elapsed if elapsed > 0 else 0
                    remaining = args.max_train_steps - global_step
                    eta_hours = remaining / steps_per_sec / 3600 if steps_per_sec > 0 else 0
                    print(
                        f"Step {global_step}/{args.max_train_steps} | "
                        f"Loss: {loss.item():.4f} | "
                        f"LR: {lr_scheduler.get_last_lr()[0]:.2e} | "
                        f"Speed: {steps_per_sec:.2f} steps/s | "
                        f"ETA: {eta_hours:.1f}h"
                    )

                if global_step % args.save_steps == 0:
                    if accelerator.is_main_process:
                        save_path = args.output_dir / f"checkpoint-{global_step}"
                        save_path.mkdir(parents=True, exist_ok=True)
                        unwrapped = accelerator.unwrap_model(transformer)
                        unwrapped.save_pretrained(save_path)
                        print(f"Saved checkpoint: {save_path}")
                    accelerator.wait_for_everyone()

    # Save final
    if accelerator.is_main_process:
        final_path = args.output_dir / "final"
        final_path.mkdir(parents=True, exist_ok=True)
        unwrapped = accelerator.unwrap_model(transformer)
        unwrapped.save_pretrained(final_path)
        total_time = (time.time() - t0) / 3600
        print(f"\nTraining complete! Saved to {final_path}")
        print(f"Total time: {total_time:.1f} hours")

    accelerator.wait_for_everyone()


if __name__ == "__main__":
    main()