""" 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()