Upload folder using huggingface_hub

scripts/training/precompute_embeddings.py

@@ -0,0 +1,184 @@
+"""
+Pre-compute VAE latents and text embeddings for Flux training.
+Removes VAE/CLIP/T5 from GPU during training, saving ~10GB VRAM per GPU.
+"""
+import argparse
+import io
+from pathlib import Path
+
+import torch
+import webdataset as wds
+from PIL import Image
+from torchvision import transforms
+from tqdm import tqdm
+
+
+def get_transform(resolution=1024):
+    return transforms.Compose([
+        transforms.Resize(resolution, interpolation=transforms.InterpolationMode.LANCZOS),
+        transforms.CenterCrop(resolution),
+        transforms.ToTensor(),
+        transforms.Normalize([0.5], [0.5]),
+    ])
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Pre-compute embeddings for Flux training")
+    parser.add_argument("--model-name", default="black-forest-labs/FLUX.1-schnell")
+    parser.add_argument("--data-dir", type=Path, default=Path("/data0/datasets/processed/flux_train/shards"))
+    parser.add_argument("--output-dir", type=Path, default=Path("/data0/datasets/processed/flux_train/embeddings"))
+    parser.add_argument("--resolution", type=int, default=1024)
+    parser.add_argument("--batch-size", type=int, default=8)
+    parser.add_argument("--cache-dir", default="/data0/models")
+    parser.add_argument("--device", default="cuda:0")
+    args = parser.parse_args()
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    device = torch.device(args.device)
+    transform = get_transform(args.resolution)
+
+    # Load pipeline components
+    print("Loading Flux pipeline components...")
+    from diffusers import FluxPipeline
+    pipe = FluxPipeline.from_pretrained(
+        args.model_name,
+        torch_dtype=torch.bfloat16,
+        cache_dir=args.cache_dir,
+    )
+
+    vae = pipe.vae.to(device).eval()
+    text_encoder = pipe.text_encoder.to(device).eval()
+    text_encoder_2 = pipe.text_encoder_2.to(device).eval()
+    tokenizer = pipe.tokenizer
+    tokenizer_2 = pipe.tokenizer_2
+
+    vae_shift = vae.config.shift_factor
+    vae_scale = vae.config.scaling_factor
+
+    # Find tar shards
+    tar_files = sorted(args.data_dir.glob("*.tar"))
+    if not tar_files:
+        raise ValueError(f"No tar files found in {args.data_dir}")
+    print(f"Found {len(tar_files)} shards")
+
+    def decode_sample(sample):
+        try:
+            img = sample["jpg"]
+            if isinstance(img, bytes):
+                img = Image.open(io.BytesIO(img)).convert("RGB")
+            caption = sample.get("txt", b"")
+            if isinstance(caption, bytes):
+                caption = caption.decode("utf-8")
+            return {"image": transform(img), "caption": caption, "key": sample["__key__"]}
+        except:
+            return None
+
+    dataset = (
+        wds.WebDataset([str(f) for f in tar_files])
+        .decode("pil")
+        .map(decode_sample)
+        .select(lambda x: x is not None)
+    )
+
+    dataloader = torch.utils.data.DataLoader(
+        dataset, batch_size=None, num_workers=4, pin_memory=True
+    )
+
+    # Process in batches
+    batch_images = []
+    batch_captions = []
+    batch_keys = []
+    sample_idx = 0
+    shard_idx = 0
+    shard_data = []
+    samples_per_shard = 1000
+
+    print(f"Pre-computing embeddings (batch_size={args.batch_size})...")
+
+    def save_shard(shard_data, shard_idx):
+        shard_path = args.output_dir / f"shard-{shard_idx:06d}.pt"
+        torch.save(shard_data, shard_path)
+        return shard_idx + 1
+
+    def process_batch(images, captions, keys):
+        imgs = torch.stack(images).to(device, dtype=torch.bfloat16)
+
+        with torch.no_grad():
+            latents = vae.encode(imgs).latent_dist.sample()
+            latents = (latents - vae_shift) * vae_scale
+
+            # Pack latents: (B, C, H, W) -> (B, H/2*W/2, C*4)
+            b, c, h, w = latents.shape
+            packed = latents.view(b, c, h // 2, 2, w // 2, 2)
+            packed = packed.permute(0, 2, 4, 1, 3, 5).reshape(b, (h // 2) * (w // 2), c * 4)
+
+            # Text embeddings
+            text_ids = tokenizer(
+                captions, padding="max_length", max_length=77,
+                truncation=True, return_tensors="pt"
+            ).input_ids.to(device)
+            pooled = text_encoder(text_ids, output_hidden_states=False).pooler_output
+
+            text_ids_2 = tokenizer_2(
+                captions, padding="max_length", max_length=256,
+                truncation=True, return_tensors="pt"
+            ).input_ids.to(device)
+            hidden_states = text_encoder_2(text_ids_2)[0]
+
+            # Latent image IDs
+            latent_h, latent_w = h // 2, w // 2
+            img_ids = torch.zeros(latent_h, latent_w, 3, device=device)
+            img_ids[..., 1] = torch.arange(latent_h)[:, None].float()
+            img_ids[..., 2] = torch.arange(latent_w)[None, :].float()
+            img_ids = img_ids.reshape(latent_h * latent_w, 3)
+
+            # Text IDs
+            txt_ids = torch.zeros(hidden_states.shape[1], 3, device=device)
+
+        results = []
+        for i in range(b):
+            results.append({
+                "key": keys[i],
+                "packed_latents": packed[i].cpu(),
+                "pooled_prompt_embeds": pooled[i].cpu(),
+                "encoder_hidden_states": hidden_states[i].cpu(),
+                "img_ids": img_ids.cpu(),
+                "txt_ids": txt_ids.cpu(),
+            })
+        return results
+
+    total_processed = 0
+    for sample in dataloader:
+        batch_images.append(sample["image"])
+        batch_captions.append(sample["caption"])
+        batch_keys.append(sample["key"])
+
+        if len(batch_images) >= args.batch_size:
+            results = process_batch(batch_images, batch_captions, batch_keys)
+            shard_data.extend(results)
+            total_processed += len(results)
+
+            if len(shard_data) >= samples_per_shard:
+                shard_idx = save_shard(shard_data, shard_idx)
+                print(f"  Saved shard {shard_idx - 1} ({total_processed} samples total)")
+                shard_data = []
+
+            batch_images = []
+            batch_captions = []
+            batch_keys = []
+
+    # Process remaining
+    if batch_images:
+        results = process_batch(batch_images, batch_captions, batch_keys)
+        shard_data.extend(results)
+        total_processed += len(results)
+
+    if shard_data:
+        shard_idx = save_shard(shard_data, shard_idx)
+        print(f"  Saved shard {shard_idx - 1} ({total_processed} samples total)")
+
+    print(f"\nDone! {total_processed} samples saved to {args.output_dir} ({shard_idx} shards)")
+
+
+if __name__ == "__main__":
+    main()

scripts/training/run_train_flux_deepspeed.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# Flux LoRA Training with DeepSpeed ZeRO-3 on 2x H100 NVL
+# Step 1: Pre-compute embeddings (one-time)
+# Step 2: Train with both GPUs in parallel
+#
+# Usage: bash scripts/training/run_train_flux_deepspeed.sh
+
+set -e
+
+PROJECT_DIR="/home/adminuser/chungcat"
+EMBEDDING_DIR="/data0/datasets/processed/flux_train/embeddings"
+SHARD_DIR="/data0/datasets/processed/flux_train/shards"
+
+export PYTHONPATH="$PROJECT_DIR:$PYTHONPATH"
+export HF_HOME="/home/adminuser/.cache/huggingface"
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+
+# Step 1: Pre-compute embeddings if not done
+if [ ! -d "$EMBEDDING_DIR" ] || [ $(ls "$EMBEDDING_DIR"/shard-*.pt 2>/dev/null | wc -l) -eq 0 ]; then
+    echo "=== Pre-computing embeddings ==="
+    python3 "$PROJECT_DIR/scripts/training/precompute_embeddings.py" \
+        --data-dir "$SHARD_DIR" \
+        --output-dir "$EMBEDDING_DIR" \
+        --batch-size 8 \
+        --device cuda:0
+    echo "=== Embeddings ready ==="
+fi
+
+# Step 2: Launch DeepSpeed training on 2 GPUs
+echo "=== Starting DeepSpeed ZeRO-3 Training ==="
+accelerate launch \
+    --config_file "$PROJECT_DIR/configs/accelerate_config.yaml" \
+    "$PROJECT_DIR/scripts/training/train_flux_deepspeed.py" \
+    --embedding-dir "$EMBEDDING_DIR" \
+    --output-dir "/data0/checkpoints/flux_lora_ds" \
+    --batch-size 4 \
+    --gradient-accumulation 4 \
+    --learning-rate 1e-4 \
+    --lr-warmup-steps 500 \
+    --max-train-steps 100000 \
+    --save-steps 5000 \
+    --lora-rank 128 \
+    --lora-alpha 128

scripts/training/train_flux_deepspeed.py

@@ -0,0 +1,247 @@
+"""
+Flux LoRA Training with DeepSpeed ZeRO-3.
+Uses pre-computed embeddings for maximum GPU efficiency.
+Both GPUs train the transformer in parallel.
+"""
+import argparse
+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 diffusers import FluxTransformer2DModel
+from diffusers.optimization import get_scheduler
+from peft import LoraConfig, get_peft_model
+
+
+class EmbeddingDataset(Dataset):
+    """Load pre-computed latents and text embeddings from .pt shards."""
+
+    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}")
+
+        # Load index: count samples per shard
+        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 main():
+    parser = argparse.ArgumentParser(description="Flux LoRA training with DeepSpeed ZeRO-3")
+    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=4)
+    parser.add_argument("--gradient-accumulation", type=int, default=4)
+    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)
+    args = parser.parse_args()
+
+    accelerator = Accelerator(
+        mixed_precision="bf16",
+        gradient_accumulation_steps=args.gradient_accumulation,
+    )
+
+    if accelerator.is_main_process:
+        args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    torch.manual_seed(args.seed)
+
+    # Load only the transformer (no VAE/CLIP/T5 needed)
+    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,
+    )
+
+    transformer.enable_gradient_checkpointing()
+
+    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)
+
+    if accelerator.is_main_process:
+        transformer.print_trainable_parameters()
+
+    optimizer = torch.optim.AdamW(
+        [p for p in transformer.parameters() if p.requires_grad],
+        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=4,
+        pin_memory=True,
+        drop_last=True,
+    )
+
+    # Prepare with Accelerator (handles DeepSpeed wrapping)
+    transformer, optimizer, dataloader, lr_scheduler = accelerator.prepare(
+        transformer, optimizer, dataloader, lr_scheduler
+    )
+
+    # Training loop
+    global_step = 0
+    t0 = time.time()
+
+    if accelerator.is_main_process:
+        print(f"\nStarting training...")
+        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]  # same for all samples at same resolution
+                txt_ids = batch["txt_ids"][0]
+
+                bs = packed_latents.shape[0]
+
+                # Flow matching: sample timestep, create noisy latents
+                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 * 1000).to(dtype=packed_latents.dtype)
+
+                # Forward pass
+                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: velocity (noise - signal)
+                target = noise - packed_latents
+                loss = F.mse_loss(model_pred, target)
+
+                accelerator.backward(loss)
+
+                if accelerator.sync_gradients:
+                    accelerator.clip_grad_norm_(
+                        [p for p in transformer.parameters() if p.requires_grad], 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_per_sec = global_step / elapsed
+                    eta_hours = (args.max_train_steps - global_step) / steps_per_sec / 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"Speed: {steps_per_sec:.2f} steps/s | "
+                        f"ETA: {eta_hours:.1f}h"
+                    )
+
+                if global_step % args.save_steps == 0 and 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}")
+
+    # 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")
+
+
+if __name__ == "__main__":
+    main()