Fix NaN: rewrite training loop - proper grad accum, zero_grad before loop, correct loss averaging

scripts/training/train_flux_lora.py

@@ -222,6 +222,7 @@ def main():
     # Training loop
     global_step = resume_step
     accum_loss = 0.0
+    accum_count = 0
     t0 = time.time()
 
     print(f"\n  Starting training from step {global_step}...")
@@ -230,6 +231,8 @@ def main():
     print(f"    Encode: {encode_device}, Train: {train_device}")
     print(f"    Save every {args.save_steps} steps")
 
+    optimizer.zero_grad()
+
     while global_step < args.max_train_steps:
         for batch in train_dataloader:
             if global_step >= args.max_train_steps:
@@ -255,13 +258,6 @@ def main():
                 ).input_ids.to(encode_device)
                 encoder_hidden_states = text_encoder_2(text_ids_2)[0]
 
-            # Debug NaN on first step
-            if global_step == resume_step:
-                print(f"    DEBUG latents: min={latents.min():.4f} max={latents.max():.4f} nan={latents.isnan().any()}")
-                print(f"    DEBUG pooled: min={pooled_prompt_embeds.min():.4f} max={pooled_prompt_embeds.max():.4f} nan={pooled_prompt_embeds.isnan().any()}")
-                print(f"    DEBUG hidden: min={encoder_hidden_states.min():.4f} max={encoder_hidden_states.max():.4f} nan={encoder_hidden_states.isnan().any()}")
-                print(f"    DEBUG vae_shift={vae_shift} vae_scale={vae_scale}")
-
             # Move to train device
             latents = latents.to(train_device)
             pooled_prompt_embeds = pooled_prompt_embeds.to(train_device)
@@ -298,43 +294,40 @@ def main():
                 return_dict=False,
             )[0]
 
-            # Debug NaN on first few steps
-            if global_step < resume_step + 3:
-                print(f"    DEBUG step {global_step}: pred nan={model_pred.isnan().any()} target nan={target.isnan().any()} pred range=[{model_pred.min():.4f}, {model_pred.max():.4f}]", flush=True)
-
             loss = F.mse_loss(model_pred.float(), target.float())
-            loss = loss / args.gradient_accumulation
-            loss.backward()
+            scaled_loss = loss / args.gradient_accumulation
+            scaled_loss.backward()
+
             accum_loss += loss.item()
+            accum_count += 1
 
-            if (global_step + 1) % args.gradient_accumulation == 0:
+            if accum_count % args.gradient_accumulation == 0:
                 torch.nn.utils.clip_grad_norm_(trainable_params, 1.0)
                 optimizer.step()
                 lr_scheduler.step()
                 optimizer.zero_grad()
-
-            global_step += 1
-
-            if global_step % 50 == 0:
-                elapsed = time.time() - t0
-                steps_done = global_step - resume_step
-                steps_per_sec = steps_done / elapsed if elapsed > 0 else 0
-                avg_loss = accum_loss / 50 * args.gradient_accumulation
-                print(
-                    f"  Step {global_step} | "
-                    f"Loss: {avg_loss:.4f} | "
-                    f"LR: {lr_scheduler.get_last_lr()[0]:.2e} | "
-                    f"Speed: {steps_per_sec:.2f} it/s | "
-                    f"Elapsed: {elapsed/3600:.1f}h",
-                    flush=True,
-                )
-                accum_loss = 0.0
-
-            if global_step % args.save_steps == 0:
-                save_path = args.output_dir / f"checkpoint-{global_step}"
-                save_path.mkdir(parents=True, exist_ok=True)
-                transformer.save_pretrained(save_path)
-                print(f"  Saved checkpoint: {save_path}", flush=True)
+                global_step += 1
+
+                if global_step % 50 == 0:
+                    elapsed = time.time() - t0
+                    steps_done = global_step - resume_step
+                    steps_per_sec = steps_done / elapsed if elapsed > 0 else 0
+                    avg_loss = accum_loss / (50 * args.gradient_accumulation)
+                    print(
+                        f"  Step {global_step} | "
+                        f"Loss: {avg_loss:.4f} | "
+                        f"LR: {lr_scheduler.get_last_lr()[0]:.2e} | "
+                        f"Speed: {steps_per_sec:.2f} steps/s | "
+                        f"Elapsed: {elapsed/3600:.1f}h",
+                        flush=True,
+                    )
+                    accum_loss = 0.0
+
+                if global_step % args.save_steps == 0:
+                    save_path = args.output_dir / f"checkpoint-{global_step}"
+                    save_path.mkdir(parents=True, exist_ok=True)
+                    transformer.save_pretrained(save_path)
+                    print(f"  Saved checkpoint: {save_path}", flush=True)
 
     # Final save
     final_path = args.output_dir / "final"