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

vlm-streaming-sft-unsloth-qwen.py

@@ -10,27 +10,36 @@
 # ]
 # ///
 """
-Fine-tune Vision Language Models using streaming datasets and Unsloth optimizations.
+Fine-tune Vision Language Models using Unsloth optimizations.
 
-Streams data directly from the Hub - no disk space needed for massive VLM datasets.
 Uses Unsloth for ~60% less VRAM and 2x faster training.
+Supports optional train/eval split to verify generalization (not just memorization).
 
-Run locally (if you have a GPU):
-    uv run vlm-streaming-sft-unsloth.py \
-        --max-steps 100 \
+Run locally with evaluation (recommended):
+    uv run vlm-streaming-sft-unsloth-qwen.py \
+        --max-steps 200 \
+        --num-samples 500 \
+        --eval-split 0.2 \
         --output-repo your-username/vlm-test
 
 Run on HF Jobs:
-    hf jobs uv run vlm-streaming-sft-unsloth.py \
-        --flavor a100-large \
-        --secrets HF_TOKEN \
-        -- \
+    hf jobs uv run --flavor a100-large --secrets HF_TOKEN -- \
+        https://huggingface.co/datasets/uv-scripts/training/raw/main/vlm-streaming-sft-unsloth-qwen.py \
+        --max-steps 200 \
+        --num-samples 500 \
+        --eval-split 0.2 \
+        --output-repo your-username/vlm-finetuned
+
+For very large datasets, use streaming mode:
+    uv run vlm-streaming-sft-unsloth-qwen.py \
+        --streaming \
         --max-steps 500 \
         --output-repo your-username/vlm-finetuned
 
 With Trackio dashboard:
-    uv run vlm-streaming-sft-unsloth.py \
-        --max-steps 500 \
+    uv run vlm-streaming-sft-unsloth-qwen.py \
+        --max-steps 200 \
+        --eval-split 0.2 \
         --output-repo your-username/vlm-finetuned \
         --trackio-space your-username/trackio
 """
@@ -163,6 +172,32 @@ Examples:
         help="Local directory to save model (default: vlm-streaming-output)",
     )
 
+    # Evaluation and data control
+    parser.add_argument(
+        "--eval-split",
+        type=float,
+        default=0.0,
+        help="Fraction of data for evaluation (0.0-0.5). Default: 0.0 (no eval)",
+    )
+    parser.add_argument(
+        "--num-samples",
+        type=int,
+        default=None,
+        help="Limit samples (default: None = use all for non-streaming, 500 for streaming)",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=3407,
+        help="Random seed for reproducibility (default: 3407)",
+    )
+    parser.add_argument(
+        "--streaming",
+        action="store_true",
+        default=False,
+        help="Use streaming mode (default: False). Use for very large datasets.",
+    )
+
     return parser.parse_args()
 
 
@@ -170,11 +205,19 @@ def main():
     args = parse_args()
 
     print("=" * 70)
-    print("VLM Streaming Fine-tuning with Unsloth")
+    print("VLM Fine-tuning with Unsloth")
     print("=" * 70)
     print("\nConfiguration:")
     print(f"  Base model:      {args.base_model}")
     print(f"  Dataset:         {args.dataset}")
+    print(f"  Streaming:       {args.streaming}")
+    print(
+        f"  Num samples:     {args.num_samples or ('500' if args.streaming else 'all')}"
+    )
+    print(
+        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"  Batch size:      {args.batch_size} x {args.gradient_accumulation} = {args.batch_size * args.gradient_accumulation}"
@@ -194,7 +237,9 @@ def main():
     # Set Trackio space if provided
     if args.trackio_space:
         os.environ["TRACKIO_SPACE_ID"] = args.trackio_space
-        logger.info(f"Trackio dashboard: https://huggingface.co/spaces/{args.trackio_space}")
+        logger.info(
+            f"Trackio dashboard: https://huggingface.co/spaces/{args.trackio_space}"
+        )
 
     # Import heavy dependencies (note: import from unsloth.trainer for VLM)
     from unsloth import FastVisionModel
@@ -237,31 +282,74 @@ def main():
     )
     print(f"Model loaded in {time.time() - start:.1f}s")
 
-    # 2. Load streaming dataset
-    print("\n[2/5] Loading streaming dataset...")
-    start = time.time()
-
-    dataset = load_dataset(
-        args.dataset,
-        split="train",
-        streaming=True,
+    # 2. Load dataset (streaming or non-streaming)
+    print(
+        f"\n[2/5] Loading dataset ({'streaming' if args.streaming else 'non-streaming'})..."
     )
+    start = time.time()
 
-    # Peek at first sample to show info
-    sample = next(iter(dataset))
-    print(f"Dataset ready in {time.time() - start:.1f}s")
-    if "messages" in sample:
-        print(f"  Sample has {len(sample['messages'])} messages")
-    if "images" in sample:
-        img_count = len(sample['images']) if isinstance(sample['images'], list) else 1
-        print(f"  Sample has {img_count} image(s)")
-
-    # Reload dataset (consumed one sample above)
-    dataset = load_dataset(
-        args.dataset,
-        split="train",
-        streaming=True,
-    )
+    if args.streaming:
+        # Streaming mode: take limited samples
+        dataset = load_dataset(args.dataset, split="train", streaming=True)
+        num_samples = args.num_samples or 500
+
+        # Peek at first sample to show info
+        sample = next(iter(dataset))
+        if "messages" in sample:
+            print(f"  Sample has {len(sample['messages'])} messages")
+        if "images" in sample:
+            img_count = (
+                len(sample["images"]) if isinstance(sample["images"], list) else 1
+            )
+            print(f"  Sample has {img_count} image(s)")
+
+        # Reload and take samples
+        dataset = load_dataset(args.dataset, split="train", streaming=True)
+        all_data = list(dataset.take(num_samples))
+        print(f"  Loaded {len(all_data)} samples in {time.time() - start:.1f}s")
+
+        if args.eval_split > 0:
+            # Manual shuffle for streaming (no built-in split)
+            import random
+
+            random.seed(args.seed)
+            random.shuffle(all_data)
+            split_idx = int(len(all_data) * (1 - args.eval_split))
+            train_data = all_data[:split_idx]
+            eval_data = all_data[split_idx:]
+            print(f"  Train: {len(train_data)} samples, Eval: {len(eval_data)} samples")
+        else:
+            train_data = all_data
+            eval_data = None
+    else:
+        # Non-streaming: use proper train_test_split
+        dataset = load_dataset(args.dataset, split="train")
+        print(f"  Dataset has {len(dataset)} total samples")
+
+        # Peek at first sample
+        sample = dataset[0]
+        if "messages" in sample:
+            print(f"  Sample has {len(sample['messages'])} messages")
+        if "images" in sample:
+            img_count = (
+                len(sample["images"]) if isinstance(sample["images"], list) else 1
+            )
+            print(f"  Sample has {img_count} image(s)")
+
+        if args.num_samples:
+            dataset = dataset.select(range(min(args.num_samples, len(dataset))))
+            print(f"  Limited to {len(dataset)} samples")
+
+        if args.eval_split > 0:
+            split = dataset.train_test_split(test_size=args.eval_split, seed=args.seed)
+            train_data = list(split["train"])
+            eval_data = list(split["test"])
+            print(f"  Train: {len(train_data)} samples, Eval: {len(eval_data)} samples")
+        else:
+            train_data = list(dataset)
+            eval_data = None
+
+        print(f"  Dataset ready in {time.time() - start:.1f}s")
 
     # 3. Configure trainer
     print("\n[3/5] Configuring trainer...")
@@ -280,7 +368,7 @@ def main():
         optim="adamw_8bit",  # Per notebook
         weight_decay=0.001,
         lr_scheduler_type="linear",  # Per notebook (not cosine)
-        seed=3407,
+        seed=args.seed,
         # VLM-specific settings (required for Unsloth)
         remove_unused_columns=False,
         dataset_text_field="",
@@ -288,13 +376,14 @@ def main():
         max_length=args.max_seq_length,
         # Logging
         report_to="trackio",
-        run_name=f"vlm-streaming-{args.max_steps}steps",
+        run_name=f"vlm-sft-{args.max_steps}steps",
     )
 
-    # Convert streaming dataset to list (required for Qwen3-VL per Unsloth docs)
-    print("  Converting streaming dataset to list...")
-    train_data = list(dataset.take(500))  # Take enough samples for training
-    print(f"  Loaded {len(train_data)} samples")
+    # 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")
 
     # Use older 'tokenizer=' parameter (not processing_class) - required for Unsloth VLM
     trainer = SFTTrainer(
@@ -302,6 +391,7 @@ def main():
         tokenizer=tokenizer,  # Full processor, not processor.tokenizer
         data_collator=UnslothVisionDataCollator(model, tokenizer),
         train_dataset=train_data,
+        eval_dataset=eval_data,  # None if no eval
         args=training_config,
     )
 
@@ -309,12 +399,36 @@ def main():
     print(f"\n[4/5] Training for {args.max_steps} steps...")
     start = time.time()
 
-    trainer.train()
+    train_result = trainer.train()
 
     train_time = time.time() - start
     print(f"\nTraining completed in {train_time / 60:.1f} minutes")
     print(f"  Speed: {args.max_steps / train_time:.2f} steps/s")
 
+    # Print training metrics
+    if train_result.metrics:
+        train_loss = train_result.metrics.get("train_loss")
+        if train_loss:
+            print(f"  Final train loss: {train_loss:.4f}")
+
+    # Print eval results if eval was enabled
+    if eval_data:
+        print("\nRunning final evaluation...")
+        eval_results = trainer.evaluate()
+        eval_loss = eval_results.get("eval_loss")
+        if eval_loss:
+            print(f"  Final eval loss: {eval_loss:.4f}")
+            if train_loss:
+                ratio = eval_loss / train_loss
+                if ratio > 1.5:
+                    print(
+                        f"  ⚠️  Eval loss is {ratio:.1f}x train loss - possible overfitting"
+                    )
+                else:
+                    print(
+                        f"  ✓  Eval/train ratio: {ratio:.2f} - model generalizes well"
+                    )
+
     # 5. Save and push
     print("\n[5/5] Saving model...")
 
@@ -337,27 +451,36 @@ if __name__ == "__main__":
     # Show example usage if no arguments
     if len(sys.argv) == 1:
         print("=" * 70)
-        print("VLM Streaming Fine-tuning with Unsloth")
+        print("VLM Fine-tuning with Unsloth")
         print("=" * 70)
-        print("\nFine-tune Vision-Language Models using streaming datasets.")
-        print("Data streams directly from the Hub - no disk space needed.")
+        print("\nFine-tune Vision-Language Models with optional train/eval split.")
         print("\nFeatures:")
         print("  - ~60% less VRAM with Unsloth optimizations")
         print("  - 2x faster training vs standard methods")
+        print("  - Optional evaluation to detect overfitting")
         print("  - Trackio integration for monitoring")
         print("  - Works with any VLM dataset in conversation format")
-        print("\nExample usage:")
-        print("\n  uv run vlm-streaming-sft-unsloth.py \\")
-        print("      --max-steps 500 \\")
+        print("\nExample usage (with evaluation):")
+        print("\n  uv run vlm-streaming-sft-unsloth-qwen.py \\")
+        print("      --max-steps 200 \\")
+        print("      --num-samples 500 \\")
+        print("      --eval-split 0.2 \\")
         print("      --output-repo your-username/vlm-finetuned")
         print("\nHF Jobs example:")
-        print("\n  hf jobs uv run vlm-streaming-sft-unsloth.py \\")
-        print("      --flavor a100-large \\")
-        print("      --secrets HF_TOKEN \\")
-        print("      -- \\")
+        print("\n  hf jobs uv run --flavor a100-large --secrets HF_TOKEN -- \\")
+        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("      --eval-split 0.2 \\")
+        print("      --output-repo your-username/vlm-finetuned")
+        print("\nFor large datasets, use --streaming to avoid loading all data:")
+        print("\n  uv run vlm-streaming-sft-unsloth-qwen.py \\")
+        print("      --streaming \\")
         print("      --max-steps 500 \\")
         print("      --output-repo your-username/vlm-finetuned")
-        print("\nFor full help: uv run vlm-streaming-sft-unsloth.py --help")
+        print("\nFor full help: uv run vlm-streaming-sft-unsloth-qwen.py --help")
         print("=" * 70)
         sys.exit(0)