Upload folder using huggingface_hub

scripts/training/train_flux_lora.py

@@ -28,6 +28,12 @@ def get_train_transforms(resolution=1024):
     ])
 
 
+def collate_batch(samples):
+    images = torch.stack([s["image"] for s in samples])
+    captions = [s["caption"] for s in samples]
+    return {"image": images, "caption": captions}
+
+
 def create_webdataset(data_dir, resolution=1024, batch_size=4):
     transform = get_train_transforms(resolution)
 
@@ -46,11 +52,11 @@ 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)
+        wds.WebDataset([str(f) for f in tar_files], shardshuffle=True, nodesplitter=wds.split_by_node)
         .shuffle(1000)
         .decode("pil")
         .map(preprocess)
-        .batched(batch_size)
+        .batched(batch_size, collation_fn=collate_batch)
     )
     return dataset
 
@@ -144,9 +150,9 @@ def main():
         train_dataset, batch_size=None, num_workers=4, pin_memory=True
     )
 
-    # Prepare with accelerator
-    transformer, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
-        transformer, optimizer, train_dataloader, lr_scheduler
+    # 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
@@ -158,6 +164,13 @@ def main():
     global_step = 0
     print(f"Starting training for {args.max_train_steps} steps...")
 
+    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
+
     transformer.train()
     for batch in train_dataloader:
         if global_step >= args.max_train_steps:
@@ -172,38 +185,61 @@ def main():
                 latents = vae.encode(images).latent_dist.sample()
                 latents = (latents - vae.config.shift_factor) * vae.config.scaling_factor
 
-            # Encode text
+            # Encode text: CLIP for pooled, T5 for sequence
             with torch.no_grad():
+                # CLIP text encoder -> pooled embeddings
                 text_input_ids = tokenizer(
                     captions, padding="max_length", max_length=77,
                     truncation=True, return_tensors="pt"
                 ).input_ids.to(accelerator.device)
-                encoder_hidden_states = text_encoder(text_input_ids)[0]
+                pooled_prompt_embeds = text_encoder(text_input_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,
                     truncation=True, return_tensors="pt"
                 ).input_ids.to(accelerator.device)
-                pooled_prompt_embeds = text_encoder_2(text_input_ids_2)[0]
+                encoder_hidden_states = text_encoder_2(text_input_ids_2)[0]
 
-            # Sample noise and timesteps
+            # Flow matching: sample timesteps uniformly and interpolate
             noise = torch.randn_like(latents)
-            timesteps = torch.randint(0, 1000, (latents.shape[0],), device=latents.device).long()
+            t = torch.rand(latents.shape[0], device=latents.device, dtype=latents.dtype)
+            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)
+
+            # Flux expects timesteps scaled to [0, 1000]
+            timesteps = (t * 1000).to(dtype=noisy_latents.dtype)
+
+            # Generate image position IDs
+            b, seq_len, _ = noisy_latents.shape
+            img_ids = torch.zeros(seq_len, 3, device=accelerator.device, dtype=noisy_latents.dtype)
+            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)
 
-            # Add noise to latents
-            noisy_latents = pipe.scheduler.add_noise(latents, noise, timesteps)
+            # Text position IDs
+            txt_ids = torch.zeros(b, encoder_hidden_states.shape[1], 3, device=accelerator.device, dtype=noisy_latents.dtype)
 
-            # Predict noise
+            # Predict velocity
             model_pred = transformer(
                 hidden_states=noisy_latents,
-                timestep=timesteps,
+                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
-            loss = torch.nn.functional.mse_loss(model_pred, noise, reduction="mean")
+            # Flow matching loss
+            loss = torch.nn.functional.mse_loss(model_pred, target_latents, reduction="mean")
 
             accelerator.backward(loss)
             if accelerator.sync_gradients: