Upload vlm-streaming-sft-unsloth-qwen.py with huggingface_hub

vlm-streaming-sft-unsloth-qwen.py

@@ -13,35 +13,34 @@
 Fine-tune Vision Language Models using Unsloth optimizations.
 
 Uses Unsloth for ~60% less VRAM and 2x faster training.
-Supports optional train/eval split to verify generalization (not just memorization).
+Supports epoch-based or step-based training with optional eval split.
 
-Run locally with evaluation (recommended):
+Epoch-based training (recommended for full datasets):
     uv run vlm-streaming-sft-unsloth-qwen.py \
-        --max-steps 200 \
-        --num-samples 500 \
+        --num-epochs 1 \
         --eval-split 0.2 \
-        --output-repo your-username/vlm-test
+        --output-repo your-username/vlm-finetuned
 
-Run on HF Jobs:
-    hf jobs uv run --flavor a100-large --secrets HF_TOKEN -- \
+Run on HF Jobs (1 epoch with eval):
+    hf jobs uv run --flavor a100-large --secrets HF_TOKEN --timeout 4h -- \
         https://huggingface.co/datasets/uv-scripts/training/raw/main/vlm-streaming-sft-unsloth-qwen.py \
-        --max-steps 200 \
-        --num-samples 500 \
+        --num-epochs 1 \
         --eval-split 0.2 \
+        --trackio-space your-username/trackio \
         --output-repo your-username/vlm-finetuned
 
-For very large datasets, use streaming mode:
+Step-based training (for streaming or quick tests):
     uv run vlm-streaming-sft-unsloth-qwen.py \
         --streaming \
         --max-steps 500 \
         --output-repo your-username/vlm-finetuned
 
-With Trackio dashboard:
+Quick test with limited samples:
     uv run vlm-streaming-sft-unsloth-qwen.py \
-        --max-steps 200 \
+        --num-samples 500 \
+        --num-epochs 2 \
         --eval-split 0.2 \
-        --output-repo your-username/vlm-finetuned \
-        --trackio-space your-username/trackio
+        --output-repo your-username/vlm-test
 """
 
 import argparse
@@ -115,11 +114,17 @@ Examples:
     )
 
     # Training config
+    parser.add_argument(
+        "--num-epochs",
+        type=float,
+        default=None,
+        help="Number of epochs (default: None). Use instead of --max-steps for non-streaming mode.",
+    )
     parser.add_argument(
         "--max-steps",
         type=int,
-        default=500,
-        help="Training steps (default: 500). Required for streaming datasets.",
+        default=None,
+        help="Training steps (default: None). Required for streaming mode, optional otherwise.",
     )
     parser.add_argument(
         "--batch-size",
@@ -204,6 +209,25 @@ Examples:
 def main():
     args = parse_args()
 
+    # Validate epochs/steps configuration
+    if args.streaming and args.num_epochs:
+        logger.error(
+            "Cannot use --num-epochs with --streaming. Use --max-steps instead."
+        )
+        sys.exit(1)
+    if args.streaming and not args.max_steps:
+        args.max_steps = 500  # Default for streaming
+        logger.info("Using default --max-steps=500 for streaming mode")
+    if not args.streaming and not args.num_epochs and not args.max_steps:
+        args.num_epochs = 1  # Default to 1 epoch for non-streaming
+        logger.info("Using default --num-epochs=1 for non-streaming mode")
+
+    # Determine training duration display
+    if args.num_epochs:
+        duration_str = f"{args.num_epochs} epoch(s)"
+    else:
+        duration_str = f"{args.max_steps} steps"
+
     print("=" * 70)
     print("VLM Fine-tuning with Unsloth")
     print("=" * 70)
@@ -218,7 +242,7 @@ def main():
         f"  Eval split:      {args.eval_split if args.eval_split > 0 else '(disabled)'}"
     )
     print(f"  Seed:            {args.seed}")
-    print(f"  Max steps:       {args.max_steps}")
+    print(f"  Training:        {duration_str}")
     print(
         f"  Batch size:      {args.batch_size} x {args.gradient_accumulation} = {args.batch_size * args.gradient_accumulation}"
     )
@@ -357,17 +381,30 @@ def main():
     # Enable training mode
     FastVisionModel.for_training(model)
 
+    # Calculate steps per epoch for logging/eval intervals
+    effective_batch = args.batch_size * args.gradient_accumulation
+    steps_per_epoch = len(train_data) // effective_batch
+
+    # Determine run name and logging steps
+    if args.num_epochs:
+        run_name = f"vlm-sft-{args.num_epochs}ep"
+        logging_steps = max(1, steps_per_epoch // 10)  # ~10 logs per epoch
+    else:
+        run_name = f"vlm-sft-{args.max_steps}steps"
+        logging_steps = max(1, args.max_steps // 20)
+
     training_config = SFTConfig(
         output_dir=args.save_local,
         per_device_train_batch_size=args.batch_size,
         gradient_accumulation_steps=args.gradient_accumulation,
         warmup_steps=5,  # Per notebook (not warmup_ratio)
-        max_steps=args.max_steps,
+        num_train_epochs=args.num_epochs if args.num_epochs else 1,
+        max_steps=args.max_steps if args.max_steps else -1,  # -1 means use epochs
         learning_rate=args.learning_rate,
-        logging_steps=max(1, args.max_steps // 20),
+        logging_steps=logging_steps,
         optim="adamw_8bit",  # Per notebook
         weight_decay=0.001,
-        lr_scheduler_type="linear",  # Per notebook (not cosine)
+        lr_scheduler_type="cosine" if args.num_epochs else "linear",
         seed=args.seed,
         # VLM-specific settings (required for Unsloth)
         remove_unused_columns=False,
@@ -376,14 +413,19 @@ def main():
         max_length=args.max_seq_length,
         # Logging
         report_to="trackio",
-        run_name=f"vlm-sft-{args.max_steps}steps",
+        run_name=run_name,
     )
 
     # Add evaluation config if eval is enabled
     if eval_data:
-        training_config.eval_strategy = "steps"
-        training_config.eval_steps = max(1, args.max_steps // 5)
-        print(f"  Evaluation enabled: every {training_config.eval_steps} steps")
+        if args.num_epochs:
+            # For epoch-based training, eval at end of each epoch
+            training_config.eval_strategy = "epoch"
+            print("  Evaluation enabled: every epoch")
+        else:
+            training_config.eval_strategy = "steps"
+            training_config.eval_steps = max(1, args.max_steps // 5)
+            print(f"  Evaluation enabled: every {training_config.eval_steps} steps")
 
     # Use older 'tokenizer=' parameter (not processing_class) - required for Unsloth VLM
     trainer = SFTTrainer(
@@ -396,14 +438,21 @@ def main():
     )
 
     # 4. Train
-    print(f"\n[4/5] Training for {args.max_steps} steps...")
+    print(f"\n[4/5] Training for {duration_str}...")
+    if args.num_epochs:
+        print(
+            f"  (~{steps_per_epoch} steps/epoch, {int(steps_per_epoch * args.num_epochs)} total steps)"
+        )
     start = time.time()
 
     train_result = trainer.train()
 
     train_time = time.time() - start
+    total_steps = train_result.metrics.get(
+        "train_steps", args.max_steps or steps_per_epoch * args.num_epochs
+    )
     print(f"\nTraining completed in {train_time / 60:.1f} minutes")
-    print(f"  Speed: {args.max_steps / train_time:.2f} steps/s")
+    print(f"  Speed: {total_steps / train_time:.2f} steps/s")
 
     # Print training metrics
     if train_result.metrics:
@@ -457,25 +506,25 @@ if __name__ == "__main__":
         print("\nFeatures:")
         print("  - ~60% less VRAM with Unsloth optimizations")
         print("  - 2x faster training vs standard methods")
+        print("  - Epoch-based or step-based training")
         print("  - Optional evaluation to detect overfitting")
         print("  - Trackio integration for monitoring")
-        print("  - Works with any VLM dataset in conversation format")
-        print("\nExample usage (with evaluation):")
+        print("\nEpoch-based training (recommended for full datasets):")
         print("\n  uv run vlm-streaming-sft-unsloth-qwen.py \\")
-        print("      --max-steps 200 \\")
-        print("      --num-samples 500 \\")
+        print("      --num-epochs 1 \\")
         print("      --eval-split 0.2 \\")
         print("      --output-repo your-username/vlm-finetuned")
-        print("\nHF Jobs example:")
-        print("\n  hf jobs uv run --flavor a100-large --secrets HF_TOKEN -- \\")
+        print("\nHF Jobs example (1 epoch with eval):")
+        print(
+            "\n  hf jobs uv run --flavor a100-large --secrets HF_TOKEN --timeout 4h -- \\"
+        )
         print(
             "      https://huggingface.co/datasets/uv-scripts/training/raw/main/vlm-streaming-sft-unsloth-qwen.py \\"
         )
-        print("      --max-steps 200 \\")
-        print("      --num-samples 500 \\")
+        print("      --num-epochs 1 \\")
         print("      --eval-split 0.2 \\")
         print("      --output-repo your-username/vlm-finetuned")
-        print("\nFor large datasets, use --streaming to avoid loading all data:")
+        print("\nStep-based training (for streaming or quick tests):")
         print("\n  uv run vlm-streaming-sft-unsloth-qwen.py \\")
         print("      --streaming \\")
         print("      --max-steps 500 \\")