Upload folder using huggingface_hub

scripts/training/run_train_flux.sh

@@ -1,25 +1,29 @@
 #!/bin/bash
-# Launch Flux LoRA training on 2x H100
+# Launch Flux LoRA training - split model across 2 GPUs
+# GPU 0: VAE + CLIP + T5 (encoding)
+# GPU 1: Flux Transformer (training)
 # Usage: bash scripts/training/run_train_flux.sh
 
 export PYTHONPATH="/home/adminuser/chungcat:$PYTHONPATH"
-export TORCH_DISTRIBUTED_DEBUG=DETAIL
+export HF_HOME="/home/adminuser/.cache/huggingface"
+export WANDB_MODE=disabled
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
 
-accelerate launch \
-    --config_file /home/adminuser/chungcat/configs/accelerate_config.yaml \
-    /home/adminuser/chungcat/scripts/training/train_flux_lora.py \
+python3 /home/adminuser/chungcat/scripts/training/train_flux_lora.py \
     --model-name "black-forest-labs/FLUX.1-schnell" \
     --data-dir "/home/adminuser/chungcat/data/processed/flux_train/shards" \
     --output-dir "/home/adminuser/chungcat/checkpoints/flux_lora" \
     --resolution 1024 \
     --batch-size 1 \
-    --gradient-accumulation 4 \
+    --gradient-accumulation 8 \
     --learning-rate 1e-4 \
     --lr-scheduler cosine \
-    --lr-warmup-steps 500 \
+    --lr-warmup-steps 1000 \
     --max-train-steps 100000 \
     --save-steps 5000 \
     --lora-rank 128 \
     --lora-alpha 128 \
-    --mixed-precision bf16 \
-    --seed 42
+    --seed 42 \
+    --gradient-checkpointing \
+    --encode-device cuda:0 \
+    --train-device cuda:1

scripts/training/run_train_sr_2gpu.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+# SR Training + Auto-backup for VPS 2x H100
+# This script runs on the 2-GPU VPS:
+#   - Stage 2: SR 1K→2K
+#   - Stage 3: SR 2K→4K (after Stage 2 converges)
+#   - Auto-backup to HuggingFace every 30 minutes
+#
+# Usage: bash scripts/training/run_train_sr_2gpu.sh <hf_token>
+
+set -e
+
+HF_TOKEN=${1:-""}
+PROJECT_DIR="/home/adminuser/chungcat"
+
+if [ -z "$HF_TOKEN" ]; then
+    echo "Usage: bash scripts/training/run_train_sr_2gpu.sh <hf_token>"
+    exit 1
+fi
+
+# Login HuggingFace
+echo "=== Logging into HuggingFace ==="
+python3 -c "from huggingface_hub import login; login(token='$HF_TOKEN')"
+HF_USER=$(python3 -c "from huggingface_hub import HfApi; print(HfApi().whoami()['name'])")
+echo "Logged in as: $HF_USER"
+
+# Start auto-backup in background
+echo "=== Starting auto-backup (every 30 min) ==="
+pkill -f "backup.py --auto" 2>/dev/null || true
+nohup python3 "$PROJECT_DIR/scripts/backup.py" --auto --interval 30 --user "$HF_USER" \
+    > "$PROJECT_DIR/logs/backup.log" 2>&1 &
+echo "Auto-backup PID: $!"
+
+# Create SR pairs if not exist
+SR_PAIRS="$PROJECT_DIR/data/processed/sr_pairs"
+if [ ! -d "$SR_PAIRS/1k_input" ] || [ $(ls "$SR_PAIRS/1k_input"/*.png 2>/dev/null | wc -l) -lt 100 ]; then
+    echo "=== Creating SR pairs from 4K images ==="
+    python3 "$PROJECT_DIR/scripts/data_collection/create_sr_pairs.py" \
+        --input-dir "$PROJECT_DIR/data/processed/sr_4k/shards" \
+        --output-dir "$SR_PAIRS" 2>&1 | tail -5
+fi
+
+# Train Stage 2: 1K→2K on GPU 0
+echo "=== Starting SR Stage 2 (1K→2K) on GPU 0 ==="
+export CUDA_VISIBLE_DEVICES=0
+nohup python3 "$PROJECT_DIR/scripts/training/train_sr.py" \
+    --stage 2 \
+    --input-dir "$SR_PAIRS/1k_input" \
+    --target-dir "$SR_PAIRS/2k_target" \
+    --output-dir "$PROJECT_DIR/checkpoints/sr_stage2" \
+    --batch-size 4 \
+    --learning-rate 2e-4 \
+    --max-steps 200000 \
+    --save-steps 10000 \
+    --base-channels 64 \
+    --perceptual-weight 0.1 \
+    > "$PROJECT_DIR/logs/train_sr_stage2.log" 2>&1 &
+echo "SR Stage 2 PID: $!"
+
+# Train Stage 3: 2K→4K on GPU 1
+echo "=== Starting SR Stage 3 (2K→4K) on GPU 1 ==="
+export CUDA_VISIBLE_DEVICES=1
+nohup python3 "$PROJECT_DIR/scripts/training/train_sr.py" \
+    --stage 3 \
+    --input-dir "$SR_PAIRS/2k_input" \
+    --target-dir "$SR_PAIRS/4k_target" \
+    --output-dir "$PROJECT_DIR/checkpoints/sr_stage3" \
+    --batch-size 2 \
+    --learning-rate 2e-4 \
+    --max-steps 200000 \
+    --save-steps 10000 \
+    --base-channels 64 \
+    --perceptual-weight 0.1 \
+    > "$PROJECT_DIR/logs/train_sr_stage3.log" 2>&1 &
+echo "SR Stage 3 PID: $!"
+
+echo ""
+echo "=== All jobs started ==="
+echo "Monitor:"
+echo "  tail -f $PROJECT_DIR/logs/train_sr_stage2.log"
+echo "  tail -f $PROJECT_DIR/logs/train_sr_stage3.log"
+echo "  tail -f $PROJECT_DIR/logs/backup.log"
+echo "  nvidia-smi"

scripts/training/train_flux_lora.py

@@ -1,22 +1,16 @@
 """
 Fine-tune Flux model using LoRA on downloaded COYO dataset.
-Uses diffusers + accelerate + DeepSpeed for multi-GPU training.
+Split approach: VAE+text encoders on cuda:0, transformer on cuda:1.
 """
 import argparse
-import math
+import gc
 from pathlib import Path
 
 import torch
 import webdataset as wds
 from PIL import Image
 from torchvision import transforms
-from diffusers import FluxPipeline, FluxTransformer2DModel
-from diffusers.training_utils import compute_snr
 from peft import LoraConfig, get_peft_model
-from accelerate import Accelerator
-from accelerate.utils import ProjectConfiguration
-from transformers import CLIPTextModel, CLIPTokenizer, T5EncoderModel, T5TokenizerFast
-import wandb
 
 
 def get_train_transforms(resolution=1024):
@@ -34,7 +28,7 @@ def collate_batch(samples):
     return {"image": images, "caption": captions}
 
 
-def create_webdataset(data_dir, resolution=1024, batch_size=4):
+def create_webdataset(data_dir, resolution=1024, batch_size=1):
     transform = get_train_transforms(resolution)
 
     def preprocess(sample):
@@ -52,7 +46,7 @@ def create_webdataset(data_dir, resolution=1024, batch_size=4):
         raise ValueError(f"No tar files found in {data_dir}")
 
     dataset = (
-        wds.WebDataset([str(f) for f in tar_files], shardshuffle=True, nodesplitter=wds.split_by_node)
+        wds.WebDataset([str(f) for f in tar_files], shardshuffle=True)
         .shuffle(1000)
         .decode("pil")
         .map(preprocess)
@@ -61,6 +55,13 @@ def create_webdataset(data_dir, resolution=1024, batch_size=4):
     return dataset
 
 
+def pack_latents(latents):
+    b, c, h, w = latents.shape
+    latents = latents.reshape(b, c, h // 2, 2, w // 2, 2)
+    latents = latents.permute(0, 2, 4, 1, 3, 5).reshape(b, (h // 2) * (w // 2), c * 4)
+    return latents
+
+
 def main():
     parser = argparse.ArgumentParser(description="Fine-tune Flux with LoRA")
     parser.add_argument("--model-name", default="black-forest-labs/FLUX.1-schnell")
@@ -68,73 +69,83 @@ def main():
     parser.add_argument("--output-dir", type=Path, default=Path("/home/adminuser/chungcat/checkpoints/flux_lora"))
     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=4)
+    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("--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("--lora-rank", type=int, default=128)
     parser.add_argument("--lora-alpha", type=int, default=128)
-    parser.add_argument("--mixed-precision", default="bf16")
     parser.add_argument("--seed", type=int, default=42)
-    parser.add_argument("--use-wandb", action="store_true")
-    parser.add_argument("--wandb-project", default="flux-finetune")
+    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")
     args = parser.parse_args()
 
-    # Setup accelerator
-    project_config = ProjectConfiguration(
-        project_dir=str(args.output_dir),
-        logging_dir=str(args.output_dir / "logs"),
-    )
-    accelerator = Accelerator(
-        mixed_precision=args.mixed_precision,
-        gradient_accumulation_steps=args.gradient_accumulation,
-        project_config=project_config,
-    )
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    torch.manual_seed(args.seed)
 
-    if accelerator.is_main_process:
-        args.output_dir.mkdir(parents=True, exist_ok=True)
-        if args.use_wandb:
-            wandb.init(project=args.wandb_project, config=vars(args))
+    encode_device = torch.device(args.encode_device)
+    train_device = torch.device(args.train_device)
 
-    # Load model
-    print(f"Loading model: {args.model_name}")
-    pipe = FluxPipeline.from_pretrained(
-        args.model_name,
-        torch_dtype=torch.bfloat16,
-    )
+    # --- 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")
 
-    transformer = pipe.transformer
-    text_encoder = pipe.text_encoder
-    text_encoder_2 = pipe.text_encoder_2
-    tokenizer = pipe.tokenizer
-    tokenizer_2 = pipe.tokenizer_2
-    vae = pipe.vae
+    # --- 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
 
-    # Freeze everything except transformer
+    vae = AutoencoderKL.from_pretrained(
+        args.model_name, subfolder="vae", torch_dtype=torch.bfloat16
+    ).to(encode_device).eval()
     vae.requires_grad_(False)
+
+    text_encoder = CLIPTextModel.from_pretrained(
+        args.model_name, subfolder="text_encoder", torch_dtype=torch.bfloat16
+    ).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
+    ).to(encode_device).eval()
     text_encoder_2.requires_grad_(False)
 
-    # Apply LoRA to transformer
+    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}...")
+    from diffusers import FluxTransformer2DModel
+    transformer = FluxTransformer2DModel.from_pretrained(
+        args.model_name, subfolder="transformer", torch_dtype=torch.bfloat16
+    )
+
+    if args.gradient_checkpointing:
+        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", "proj_in", "proj_out"],
-        lora_dropout=0.05,
+        target_modules=["to_q", "to_k", "to_v", "to_out.0"],
+        lora_dropout=0.0,
     )
     transformer = get_peft_model(transformer, lora_config)
+    transformer.to(train_device)
     transformer.print_trainable_parameters()
+    transformer.train()
 
-    # Optimizer
+    # --- Optimizer + scheduler ---
     optimizer = torch.optim.AdamW(
-        transformer.parameters(),
+        [p for p in transformer.parameters() if p.requires_grad],
         lr=args.learning_rate,
         weight_decay=0.01,
     )
 
-    # Learning rate scheduler
     from diffusers.optimization import get_scheduler
     lr_scheduler = get_scheduler(
         args.lr_scheduler,
@@ -143,133 +154,117 @@ def main():
         num_training_steps=args.max_train_steps,
     )
 
-    # Dataset
+    # --- 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
     )
 
-    # Prepare with accelerator (skip dataloader — it contains strings that can't be gathered)
-    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, dtype=torch.bfloat16)
-    text_encoder_2.to(accelerator.device, dtype=torch.bfloat16)
-
-    # Training loop
+    # --- Training loop ---
     global_step = 0
-    print(f"Starting training for {args.max_train_steps} steps...")
+    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}")
 
-    def pack_latents(latents):
-        # Pack 2x2 patches: (B, C, H, W) -> (B, H//2 * W//2, C*4)
-        b, c, h, w = latents.shape
-        latents = latents.reshape(b, c, h // 2, 2, w // 2, 2)
-        latents = latents.permute(0, 2, 4, 1, 3, 5).reshape(b, (h // 2) * (w // 2), c * 4)
-        return latents
+    scaler = None  # bf16 doesn't need GradScaler
 
-    transformer.train()
-    for batch in train_dataloader:
-        if global_step >= args.max_train_steps:
-            break
+    while global_step < args.max_train_steps:
+        for batch in train_dataloader:
+            if global_step >= args.max_train_steps:
+                break
 
-        with accelerator.accumulate(transformer):
-            images = batch["image"].to(accelerator.device, dtype=torch.bfloat16)
+            images = batch["image"].to(encode_device, dtype=torch.bfloat16)
             captions = batch["caption"]
 
-            # Encode images to latents
+            # Encode on encode_device
             with torch.no_grad():
                 latents = vae.encode(images).latent_dist.sample()
-                latents = (latents - vae.config.shift_factor) * vae.config.scaling_factor
+                latents = (latents - vae_shift) * vae_scale
 
-            # Encode text: CLIP for pooled, T5 for sequence
-            with torch.no_grad():
-                # CLIP text encoder -> pooled embeddings
-                text_input_ids = tokenizer(
+                text_ids = tokenizer(
                     captions, padding="max_length", max_length=77,
                     truncation=True, return_tensors="pt"
-                ).input_ids.to(accelerator.device)
-                pooled_prompt_embeds = text_encoder(text_input_ids, output_hidden_states=False).pooler_output
+                ).input_ids.to(encode_device)
+                pooled_prompt_embeds = text_encoder(text_ids, output_hidden_states=False).pooler_output
 
-                # T5 text encoder -> sequence embeddings
-                text_input_ids_2 = tokenizer_2(
-                    captions, padding="max_length", max_length=512,
+                text_ids_2 = tokenizer_2(
+                    captions, padding="max_length", max_length=256,
                     truncation=True, return_tensors="pt"
-                ).input_ids.to(accelerator.device)
-                encoder_hidden_states = text_encoder_2(text_input_ids_2)[0]
+                ).input_ids.to(encode_device)
+                encoder_hidden_states = text_encoder_2(text_ids_2)[0]
+
+            # Move to train device
+            latents = latents.to(train_device)
+            pooled_prompt_embeds = pooled_prompt_embeds.to(train_device)
+            encoder_hidden_states = encoder_hidden_states.to(train_device)
 
-            # Flow matching: sample timesteps uniformly and interpolate
+            # Flow matching
             noise = torch.randn_like(latents)
-            t = torch.rand(latents.shape[0], device=latents.device, dtype=latents.dtype)
+            t = torch.rand(latents.shape[0], device=train_device, dtype=torch.bfloat16)
             t_expand = t.view(-1, 1, 1, 1)
-
-            # Noisy latents via linear interpolation
             noisy_latents = (1 - t_expand) * latents + t_expand * noise
 
-            # Pack latents into sequence format for transformer
-            noisy_latents = pack_latents(noisy_latents)
-            target_latents = pack_latents(noise - latents)
+            noisy_packed = pack_latents(noisy_latents)
+            target = pack_latents(noise - latents)
 
-            # Flux expects timesteps scaled to [0, 1000]
-            timesteps = (t * 1000).to(dtype=noisy_latents.dtype)
+            timesteps = (t * 1000).to(dtype=torch.bfloat16)
 
-            # Generate image position IDs
-            b, seq_len, _ = noisy_latents.shape
-            img_ids = torch.zeros(seq_len, 3, device=accelerator.device, dtype=noisy_latents.dtype)
+            b, seq_len, _ = noisy_packed.shape
             h_patches = w_patches = int(seq_len ** 0.5)
-            img_ids[:, 1] = torch.arange(h_patches, device=accelerator.device).repeat_interleave(w_patches).to(noisy_latents.dtype)
-            img_ids[:, 2] = torch.arange(w_patches, device=accelerator.device).repeat(h_patches).to(noisy_latents.dtype)
-            img_ids = img_ids.unsqueeze(0).expand(b, -1, -1)
-
-            # Text position IDs
-            txt_ids = torch.zeros(b, encoder_hidden_states.shape[1], 3, device=accelerator.device, dtype=noisy_latents.dtype)
-
-            # Predict velocity
-            model_pred = transformer(
-                hidden_states=noisy_latents,
-                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]
-
-            # Flow matching loss
-            loss = torch.nn.functional.mse_loss(model_pred, target_latents, reduction="mean")
-
-            accelerator.backward(loss)
-            if accelerator.sync_gradients:
-                accelerator.clip_grad_norm_(transformer.parameters(), 1.0)
-            optimizer.step()
-            lr_scheduler.step()
-            optimizer.zero_grad()
-
-        if accelerator.sync_gradients:
+            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)
+
+            txt_ids = torch.zeros(b, 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
+
+            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()
+
             global_step += 1
 
             if global_step % 100 == 0:
-                if accelerator.is_main_process:
-                    print(f"Step {global_step}/{args.max_train_steps}, Loss: {loss.item():.4f}, LR: {lr_scheduler.get_last_lr()[0]:.2e}")
-                    if args.use_wandb:
-                        wandb.log({"loss": loss.item(), "lr": lr_scheduler.get_last_lr()[0], "step": global_step})
+                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}")
+                accum_loss = 0.0
 
             if global_step % args.save_steps == 0:
-                if accelerator.is_main_process:
-                    save_path = args.output_dir / f"checkpoint-{global_step}"
-                    accelerator.unwrap_model(transformer).save_pretrained(save_path)
-                    print(f"Saved checkpoint to {save_path}")
-
-    # Save final model
-    if accelerator.is_main_process:
-        final_path = args.output_dir / "final"
-        accelerator.unwrap_model(transformer).save_pretrained(final_path)
-        print(f"Training complete! Final model saved to {final_path}")
-        if args.use_wandb:
-            wandb.finish()
+                save_path = args.output_dir / f"checkpoint-{global_step}"
+                transformer.save_pretrained(save_path)
+                print(f"Saved checkpoint to {save_path}")
+
+    # Save final
+    final_path = args.output_dir / "final"
+    transformer.save_pretrained(final_path)
+    print(f"Training complete! Final model saved to {final_path}")
 
 
 if __name__ == "__main__":