Duplicate from unsloth/jobs

Co-authored-by: Daniel van Strien <[email protected]>

.gitattributes

@@ -0,0 +1,59 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,172 @@
+---
+viewer: false
+tags:
+  - uv-script
+  - unsloth
+  - training
+  - hf-jobs
+  - vlm
+  - fine-tuning
+---
+
+# 🦥 Unsloth Training Scripts for HF Jobs
+
+UV scripts for fine-tuning LLMs and VLMs using [Unsloth](https://github.com/unslothai/unsloth) on [HF Jobs](https://huggingface.co/docs/hub/jobs) (on-demand cloud GPUs). UV handles dependency installation automatically, so you can run these scripts directly without any local setup.
+
+These scripts can also be used or adapted by agents to train models for you.
+
+## Prerequisites
+
+- A Hugging Face account
+- The [HF CLI](https://huggingface.co/docs/huggingface_hub/main/en/guides/cli) installed and authenticated (`hf auth login`)
+- A dataset on the Hub in the appropriate format (see format requirements below). A strong LLM agent can often convert your data into the right format if needed.
+
+## Data Formats
+
+### LLM Fine-tuning (SFT)
+
+Requires conversation data in ShareGPT or similar format:
+
+```python
+{
+    "messages": [
+        {"from": "human", "value": "What is the capital of France?"},
+        {"from": "gpt", "value": "The capital of France is Paris."}
+    ]
+}
+```
+
+The script auto-converts common formats (ShareGPT, Alpaca, etc.) via `standardize_data_formats`. See [mlabonne/FineTome-100k](https://huggingface.co/datasets/mlabonne/FineTome-100k) for a working dataset example.
+
+### VLM Fine-tuning
+
+Requires `images` and `messages` columns:
+
+```python
+{
+    "images": [<PIL.Image>],  # List of images
+    "messages": [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image"},
+                {"type": "text", "text": "What's in this image?"}
+            ]
+        },
+        {
+            "role": "assistant",
+            "content": [
+                {"type": "text", "text": "A golden retriever playing fetch in a park."}
+            ]
+        }
+    ]
+}
+```
+
+See [davanstrien/iconclass-vlm-sft](https://huggingface.co/datasets/davanstrien/iconclass-vlm-sft) for a working dataset example, and [davanstrien/iconclass-vlm-qwen3-best](https://huggingface.co/davanstrien/iconclass-vlm-qwen3-best) for a model trained with these scripts.
+
+### Continued Pretraining
+
+Any dataset with a text column:
+
+```python
+{"text": "Your domain-specific text here..."}
+```
+
+Use `--text-column` if your column has a different name.
+
+## Usage
+
+View available options for any script:
+
+```bash
+uv run https://huggingface.co/datasets/unsloth/jobs/raw/main/sft-lfm2.5.py --help
+```
+
+### LLM fine-tuning
+
+Fine-tune [LFM2.5-1.2B-Instruct](https://huggingface.co/LiquidAI/LFM2.5-1.2B-Instruct), a compact and efficient text model from Liquid AI:
+
+```bash
+hf jobs uv run \
+  https://huggingface.co/datasets/unsloth/jobs/raw/main/sft-lfm2.5.py \
+  --flavor a10g-small --secrets HF_TOKEN --timeout 4h \
+  -- --dataset mlabonne/FineTome-100k \
+     --num-epochs 1 \
+     --eval-split 0.2 \
+     --output-repo your-username/lfm-finetuned
+```
+
+### VLM fine-tuning
+
+```bash
+hf jobs uv run \
+  https://huggingface.co/datasets/unsloth/jobs/raw/main/sft-qwen3-vl.py \
+  --flavor a100-large --secrets HF_TOKEN \
+  -- --dataset your-username/dataset \
+     --trackio-space your-username/trackio \
+     --output-repo your-username/my-model
+```
+
+### Continued pretraining
+
+```bash
+hf jobs uv run \
+  https://huggingface.co/datasets/unsloth/jobs/raw/main/continued-pretraining.py \
+  --flavor a100-large --secrets HF_TOKEN \
+  -- --dataset your-username/domain-corpus \
+     --text-column content \
+     --max-steps 1000 \
+     --output-repo your-username/domain-llm
+```
+
+### With Trackio monitoring
+
+```bash
+hf jobs uv run \
+  https://huggingface.co/datasets/unsloth/jobs/raw/main/sft-lfm2.5.py \
+  --flavor a10g-small --secrets HF_TOKEN \
+  -- --dataset mlabonne/FineTome-100k \
+     --trackio-space your-username/trackio \
+     --output-repo your-username/lfm-finetuned
+```
+
+## Scripts
+
+| Script                                                 | Base Model           | Task                          |
+| ------------------------------------------------------ | -------------------- | ----------------------------- |
+| [`sft-lfm2.5.py`](sft-lfm2.5.py)                       | LFM2.5-1.2B-Instruct | LLM fine-tuning (recommended) |
+| [`sft-qwen3-vl.py`](sft-qwen3-vl.py)                   | Qwen3-VL-8B          | VLM fine-tuning               |
+| [`sft-gemma3-vlm.py`](sft-gemma3-vlm.py)               | Gemma 3 4B           | VLM fine-tuning (smaller)     |
+| [`continued-pretraining.py`](continued-pretraining.py) | Qwen3-0.6B           | Domain adaptation             |
+
+## Common Options
+
+| Option                    | Description                            | Default      |
+| ------------------------- | -------------------------------------- | ------------ |
+| `--dataset`               | HF dataset ID                          | _required_   |
+| `--output-repo`           | Where to save trained model            | _required_   |
+| `--max-steps`             | Number of training steps               | 500          |
+| `--num-epochs`            | Train for N epochs instead of steps    | -            |
+| `--eval-split`            | Fraction for evaluation (e.g., 0.2)    | 0 (disabled) |
+| `--batch-size`            | Per-device batch size                  | 2            |
+| `--gradient-accumulation` | Gradient accumulation steps            | 4            |
+| `--lora-r`                | LoRA rank                              | 16           |
+| `--learning-rate`         | Learning rate                          | 2e-4         |
+| `--merge-model`           | Upload merged model (not just adapter) | false        |
+| `--trackio-space`         | HF Space for live monitoring           | -            |
+| `--run-name`              | Custom name for Trackio run            | auto         |
+
+## Tips
+
+- Use `--max-steps 10` to verify everything works before a full run
+- `--eval-split 0.1` helps detect overfitting
+- Run `hf jobs hardware` to see GPU pricing (A100-large ~$2.50/hr, L40S ~$1.80/hr)
+- Add `--streaming` for very large datasets
+- First training step may take a few minutes (CUDA kernel compilation)
+
+## Links
+
+- [HF Jobs Quickstart](https://huggingface.co/docs/hub/jobs-quickstart)
+- [Unsloth Documentation](https://docs.unsloth.ai/)
+- [UV Scripts Guide](https://docs.astral.sh/uv/guides/scripts/)

continued-pretraining.py

@@ -0,0 +1,411 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "unsloth",
+#     "datasets",
+#     "trl",
+#     "huggingface_hub[hf_transfer]",
+#     "trackio",
+# ]
+# ///
+"""
+Continued pretraining of language models using streaming datasets.
+
+Demonstrates domain adaptation with streaming - no disk space needed.
+Uses FineWeb-2's Latin subset as default example (1.47M texts, ~1.7GB).
+
+Run locally (if you have a GPU):
+    uv run continued-pretraining.py --output-repo your-username/qwen-latin
+
+Run on HF Jobs:
+    hf jobs uv run \
+        https://huggingface.co/datasets/unsloth/jobs/raw/main/continued-pretraining.py \
+        --flavor a100-large --secrets HF_TOKEN \
+        -- --max-steps 1000 --output-repo your-username/qwen-latin
+
+With custom dataset:
+    uv run continued-pretraining.py \
+        --dataset your-username/domain-texts \
+        --text-column content \
+        --max-steps 1000 \
+        --output-repo your-username/domain-llm
+"""
+
+import argparse
+import logging
+import os
+import sys
+import time
+
+# Force unbuffered output for HF Jobs logs
+sys.stdout.reconfigure(line_buffering=True)
+sys.stderr.reconfigure(line_buffering=True)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+def check_cuda():
+    """Check CUDA availability and exit if not available."""
+    import torch
+
+    if not torch.cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        logger.error("Run on a machine with a CUDA-capable GPU or use HF Jobs:")
+        logger.error(
+            "  hf jobs uv run https://huggingface.co/datasets/unsloth/jobs/raw/main/continued-pretraining.py --flavor a100-large ..."
+        )
+        sys.exit(1)
+    logger.info(f"CUDA available: {torch.cuda.get_device_name(0)}")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Continued pretraining of LLMs using streaming datasets",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Train on Latin (default)
+  uv run continued-pretraining.py \\
+      --max-steps 500 \\
+      --output-repo username/qwen-latin
+
+  # Custom dataset
+  uv run continued-pretraining.py \\
+      --dataset your-username/domain-texts \\
+      --text-column content \\
+      --max-steps 1000 \\
+      --output-repo username/domain-llm
+
+  # HF Jobs with monitoring
+  hf jobs uv run \\
+      https://huggingface.co/datasets/unsloth/jobs/raw/main/continued-pretraining.py \\
+      --flavor a100-large --secrets HF_TOKEN \\
+      -- --max-steps 1000 --trackio-space username/trackio --output-repo username/qwen-latin
+        """,
+    )
+    parser.add_argument(
+        "--base-model",
+        default="unsloth/Qwen3-0.6B-Base-unsloth-bnb-4bit",
+        help="Base model to fine-tune (default: unsloth/Qwen3-0.6B-Base-unsloth-bnb-4bit)",
+    )
+    parser.add_argument(
+        "--dataset",
+        default="HuggingFaceFW/fineweb-2",
+        help="Dataset for continued pretraining (default: HuggingFaceFW/fineweb-2)",
+    )
+    parser.add_argument(
+        "--dataset-config",
+        default="lat_Latn",
+        help="Dataset config/subset name (default: lat_Latn for Latin)",
+    )
+    parser.add_argument(
+        "--text-column",
+        default="text",
+        help="Column containing text data (default: text)",
+    )
+    parser.add_argument(
+        "--output-repo",
+        required=True,
+        help="HF Hub repo to push model to (e.g., 'username/qwen-latin')",
+    )
+    parser.add_argument(
+        "--max-steps",
+        type=int,
+        default=500,
+        help="Number of training steps (default: 500)",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=4,
+        help="Per-device batch size (default: 4)",
+    )
+    parser.add_argument(
+        "--gradient-accumulation",
+        type=int,
+        default=4,
+        help="Gradient accumulation steps (default: 4)",
+    )
+    parser.add_argument(
+        "--learning-rate",
+        type=float,
+        default=2e-4,
+        help="Learning rate (default: 2e-4)",
+    )
+    parser.add_argument(
+        "--max-seq-length",
+        type=int,
+        default=2048,
+        help="Maximum sequence length (default: 2048)",
+    )
+    parser.add_argument(
+        "--lora-r",
+        type=int,
+        default=16,
+        help="LoRA rank (default: 16)",
+    )
+    parser.add_argument(
+        "--save-local",
+        default="pretraining-output",
+        help="Local directory to save model (default: pretraining-output)",
+    )
+    parser.add_argument(
+        "--trackio-space",
+        default=None,
+        help="HF Space for Trackio dashboard (e.g., 'username/trackio')",
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    print("=" * 70)
+    print("Continued Pretraining with Streaming Datasets")
+    print("=" * 70)
+    print(f"\nConfiguration:")
+    print(f"  Base model:      {args.base_model}")
+    print(f"  Dataset:         {args.dataset} ({args.dataset_config})")
+    print(f"  Text column:     {args.text_column}")
+    print(f"  Max steps:       {args.max_steps}")
+    print(
+        f"  Batch size:      {args.batch_size} x {args.gradient_accumulation} = {args.batch_size * args.gradient_accumulation}"
+    )
+    print(f"  Learning rate:   {args.learning_rate}")
+    print(f"  LoRA rank:       {args.lora_r}")
+    print(f"  Output repo:     {args.output_repo}")
+    print(f"  Trackio space:   {args.trackio_space or '(not configured)'}")
+    print()
+
+    # Check CUDA before heavy imports
+    check_cuda()
+
+    # Enable fast transfers
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
+    # 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}"
+        )
+
+    # Import heavy dependencies
+    from unsloth import FastLanguageModel
+    from datasets import load_dataset
+    from trl import SFTTrainer, SFTConfig
+    from huggingface_hub import login
+
+    # Login to Hub
+    token = os.environ.get("HF_TOKEN")
+    if token:
+        login(token=token)
+        logger.info("Logged in to Hugging Face Hub")
+    else:
+        logger.warning("HF_TOKEN not set - model upload may fail")
+
+    # 1. Load model
+    print("\n[1/5] Loading model...")
+    start = time.time()
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        args.base_model,
+        max_seq_length=args.max_seq_length,
+        load_in_4bit=True,
+    )
+
+    model = FastLanguageModel.get_peft_model(
+        model,
+        r=args.lora_r,
+        lora_alpha=args.lora_r * 2,
+        lora_dropout=0,
+        target_modules=[
+            "q_proj",
+            "k_proj",
+            "v_proj",
+            "o_proj",
+            "gate_proj",
+            "up_proj",
+            "down_proj",
+        ],
+        bias="none",
+        use_gradient_checkpointing="unsloth",
+        random_state=3407,
+    )
+    print(f"Model loaded in {time.time() - start:.1f}s")
+
+    # 2. Load streaming dataset
+    print(f"\n[2/5] Loading streaming dataset ({args.dataset})...")
+    start = time.time()
+
+    # Handle dataset with or without config
+    if args.dataset_config:
+        dataset = load_dataset(
+            args.dataset,
+            name=args.dataset_config,
+            split="train",
+            streaming=True,
+        )
+    else:
+        dataset = load_dataset(
+            args.dataset,
+            split="train",
+            streaming=True,
+        )
+
+    # Peek at the data
+    sample = next(iter(dataset))
+    text_preview = (
+        sample[args.text_column][:100]
+        if args.text_column in sample
+        else "(column not found)"
+    )
+    print(f"Dataset ready in {time.time() - start:.1f}s")
+    print(f"  Sample: {text_preview}...")
+
+    # Reload dataset (consumed one sample above)
+    if args.dataset_config:
+        dataset = load_dataset(
+            args.dataset,
+            name=args.dataset_config,
+            split="train",
+            streaming=True,
+        )
+    else:
+        dataset = load_dataset(
+            args.dataset,
+            split="train",
+            streaming=True,
+        )
+
+    # 3. Format dataset
+    print("\n[3/5] Preparing dataset...")
+
+    text_column = args.text_column
+
+    def format_text(example):
+        return {"text": example[text_column] + tokenizer.eos_token}
+
+    formatted_dataset = dataset.map(format_text)
+
+    # 4. Train
+    print(f"\n[4/5] Training for {args.max_steps} steps...")
+    start = time.time()
+
+    trainer = SFTTrainer(
+        model=model,
+        tokenizer=tokenizer,
+        train_dataset=formatted_dataset,
+        args=SFTConfig(
+            per_device_train_batch_size=args.batch_size,
+            gradient_accumulation_steps=args.gradient_accumulation,
+            warmup_steps=min(10, args.max_steps // 10),
+            max_steps=args.max_steps,
+            learning_rate=args.learning_rate,
+            logging_steps=max(1, args.max_steps // 20),
+            optim="adamw_8bit",
+            weight_decay=0.01,
+            lr_scheduler_type="linear",
+            seed=3407,
+            output_dir=args.save_local,
+            report_to="trackio",
+            run_name=f"pretraining-{args.max_steps}steps",
+            dataset_text_field="text",
+            max_seq_length=args.max_seq_length,
+            packing=False,
+        ),
+    )
+
+    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")
+
+    # 5. Save and push
+    print("\n[5/5] Saving model...")
+
+    # Save locally
+    model.save_pretrained(args.save_local)
+    tokenizer.save_pretrained(args.save_local)
+    print(f"Saved locally to {args.save_local}/")
+
+    # Push to hub
+    print(f"\nPushing to {args.output_repo}...")
+    model.push_to_hub(args.output_repo, tokenizer=tokenizer)
+    print(f"Model available at: https://huggingface.co/{args.output_repo}")
+
+    # Update model card metadata with dataset info
+    from huggingface_hub import metadata_update
+
+    metadata_update(args.output_repo, {"datasets": [args.dataset]}, overwrite=True)
+    print(f"  Model card updated with dataset: {args.dataset}")
+
+    # Quick inference test
+    print("\n" + "=" * 70)
+    print("Quick inference test:")
+    print("=" * 70)
+
+    FastLanguageModel.for_inference(model)
+
+    # Use a prompt appropriate to the dataset
+    if "lat_Latn" in (args.dataset_config or ""):
+        prompt = "Lingua Latina est"
+    else:
+        prompt = "The quick brown fox"
+
+    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=64,
+        temperature=0.7,
+        do_sample=True,
+    )
+    generated = tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+    print(f"\nPrompt: {prompt}")
+    print(f"Generated: {generated}")
+
+    print("\n" + "=" * 70)
+    print("Done!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 70)
+        print("Continued Pretraining with Streaming Datasets")
+        print("=" * 70)
+        print("\nContinued pretraining for domain adaptation.")
+        print("Streams data directly from the Hub - no disk space needed.")
+        print("\nFeatures:")
+        print("  - ~60% less VRAM with Unsloth optimizations")
+        print("  - 2x faster training vs standard methods")
+        print("  - Trackio integration for monitoring")
+        print("  - Works with any text dataset")
+        print("\nDefault example (Latin):")
+        print("\n  uv run continued-pretraining.py \\")
+        print("      --max-steps 500 \\")
+        print("      --output-repo your-username/qwen-latin")
+        print("\nHF Jobs example:")
+        print("\n  hf jobs uv run \\")
+        print(
+            "      https://huggingface.co/datasets/unsloth/jobs/raw/main/continued-pretraining.py \\"
+        )
+        print("      --flavor a100-large --secrets HF_TOKEN \\")
+        print("      -- --max-steps 1000 --output-repo your-username/qwen-latin")
+        print("\nCustom dataset:")
+        print("\n  uv run continued-pretraining.py \\")
+        print("      --dataset your-username/domain-texts \\")
+        print("      --text-column content \\")
+        print("      --output-repo your-username/domain-llm")
+        print("\nFor full help: uv run continued-pretraining.py --help")
+        print("=" * 70)
+        sys.exit(0)
+
+    main()

sft-gemma3-vlm.py

@@ -0,0 +1,377 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "unsloth",
+#     "datasets",
+#     "trl",
+#     "huggingface_hub[hf_transfer]",
+#     "trackio",
+#     "transformers==4.56.2",
+#     "trl==0.22.2",
+# ]
+# ///
+"""
+Fine-tune Gemma 3 4B Vision Language Model 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.
+
+Run locally (if you have a GPU):
+    uv run sft-gemma3-vlm.py \
+        --max-steps 100 \
+        --output-repo your-username/vlm-test
+
+Run on HF Jobs:
+    hf jobs uv run \
+        https://huggingface.co/datasets/unsloth/jobs/raw/main/sft-gemma3-vlm.py \
+        --flavor a100-large --secrets HF_TOKEN \
+        -- --max-steps 500 --output-repo your-username/vlm-finetuned
+
+With Trackio dashboard:
+    uv run sft-gemma3-vlm.py \
+        --max-steps 500 \
+        --output-repo your-username/vlm-finetuned \
+        --trackio-space your-username/trackio
+"""
+
+import argparse
+import logging
+import os
+import sys
+import time
+
+# Force unbuffered output for HF Jobs logs
+sys.stdout.reconfigure(line_buffering=True)
+sys.stderr.reconfigure(line_buffering=True)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+def check_cuda():
+    """Check CUDA availability and exit if not available."""
+    import torch
+
+    if not torch.cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        logger.error("Run on a machine with a CUDA-capable GPU or use HF Jobs:")
+        logger.error(
+            "  hf jobs uv run https://huggingface.co/datasets/unsloth/jobs/raw/main/sft-gemma3-vlm.py --flavor a100-large ..."
+        )
+        sys.exit(1)
+    logger.info(f"CUDA available: {torch.cuda.get_device_name(0)}")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Fine-tune Gemma 3 4B VLM with streaming datasets using Unsloth",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Quick test run
+  uv run sft-gemma3-vlm.py \\
+      --max-steps 50 \\
+      --output-repo username/vlm-test
+
+  # Full training with Trackio monitoring
+  uv run sft-gemma3-vlm.py \\
+      --max-steps 500 \\
+      --output-repo username/vlm-finetuned \\
+      --trackio-space username/trackio
+
+  # Custom dataset
+  uv run sft-gemma3-vlm.py \\
+      --dataset your-username/your-vlm-dataset \\
+      --max-steps 1000 \\
+      --output-repo username/custom-vlm
+        """,
+    )
+
+    # Model and data
+    parser.add_argument(
+        "--base-model",
+        default="unsloth/gemma-3-4b-pt",
+        help="Base VLM model (default: unsloth/gemma-3-4b-pt)",
+    )
+    parser.add_argument(
+        "--dataset",
+        default="davanstrien/iconclass-vlm-sft",
+        help="Dataset with 'images' and 'messages' columns (default: davanstrien/iconclass-vlm-sft)",
+    )
+    parser.add_argument(
+        "--output-repo",
+        required=True,
+        help="HF Hub repo to push model to (e.g., 'username/vlm-finetuned')",
+    )
+
+    # Training config
+    parser.add_argument(
+        "--max-steps",
+        type=int,
+        default=500,
+        help="Training steps (default: 500). Required for streaming datasets.",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=2,
+        help="Per-device batch size (default: 2)",
+    )
+    parser.add_argument(
+        "--gradient-accumulation",
+        type=int,
+        default=4,
+        help="Gradient accumulation steps (default: 4). Effective batch = batch-size * this",
+    )
+    parser.add_argument(
+        "--learning-rate",
+        type=float,
+        default=2e-4,
+        help="Learning rate (default: 2e-4)",
+    )
+    parser.add_argument(
+        "--max-seq-length",
+        type=int,
+        default=2048,
+        help="Maximum sequence length (default: 2048)",
+    )
+
+    # LoRA config
+    parser.add_argument(
+        "--lora-r",
+        type=int,
+        default=16,
+        help="LoRA rank (default: 16). Higher = more capacity but more VRAM",
+    )
+    parser.add_argument(
+        "--lora-alpha",
+        type=int,
+        default=32,
+        help="LoRA alpha (default: 32). Usually 2*r",
+    )
+
+    # Logging
+    parser.add_argument(
+        "--trackio-space",
+        default=None,
+        help="HF Space for Trackio dashboard (e.g., 'username/trackio')",
+    )
+    parser.add_argument(
+        "--save-local",
+        default="vlm-gemma3-output",
+        help="Local directory to save model (default: vlm-gemma3-output)",
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    print("=" * 70)
+    print("Gemma 3 4B VLM Streaming Fine-tuning with Unsloth")
+    print("=" * 70)
+    print("\nConfiguration:")
+    print(f"  Base model:      {args.base_model}")
+    print(f"  Dataset:         {args.dataset}")
+    print(f"  Max steps:       {args.max_steps}")
+    print(
+        f"  Batch size:      {args.batch_size} x {args.gradient_accumulation} = {args.batch_size * args.gradient_accumulation}"
+    )
+    print(f"  Learning rate:   {args.learning_rate}")
+    print(f"  LoRA rank:       {args.lora_r}")
+    print(f"  Output repo:     {args.output_repo}")
+    print(f"  Trackio space:   {args.trackio_space or '(not configured)'}")
+    print()
+
+    # Check CUDA before heavy imports
+    check_cuda()
+
+    # Enable fast transfers
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
+    # 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}"
+        )
+
+    # Import heavy dependencies (note: import from unsloth.trainer for VLM)
+    from unsloth import FastVisionModel, get_chat_template
+    from unsloth.trainer import UnslothVisionDataCollator
+    from datasets import load_dataset
+    from trl import SFTTrainer, SFTConfig
+    from huggingface_hub import login
+
+    # Login to Hub
+    token = os.environ.get("HF_TOKEN")
+    if token:
+        login(token=token)
+        logger.info("Logged in to Hugging Face Hub")
+    else:
+        logger.warning("HF_TOKEN not set - model upload may fail")
+
+    # 1. Load model
+    print("\n[1/5] Loading model...")
+    start = time.time()
+
+    model, processor = FastVisionModel.from_pretrained(
+        args.base_model,
+        load_in_4bit=True,
+        use_gradient_checkpointing="unsloth",
+    )
+
+    model = FastVisionModel.get_peft_model(
+        model,
+        finetune_vision_layers=True,
+        finetune_language_layers=True,
+        finetune_attention_modules=True,
+        finetune_mlp_modules=True,
+        r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=0,
+        bias="none",
+        random_state=3407,
+        use_rslora=False,
+        loftq_config=None,
+        target_modules="all-linear",
+    )
+
+    # Apply chat template (required for base models)
+    processor = get_chat_template(processor, "gemma-3")
+    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,
+    )
+
+    # 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,
+    )
+
+    # 3. Configure trainer
+    print("\n[3/5] Configuring trainer...")
+
+    # Enable training mode
+    FastVisionModel.for_training(model)
+
+    training_config = SFTConfig(
+        output_dir=args.save_local,
+        per_device_train_batch_size=args.batch_size,
+        gradient_accumulation_steps=args.gradient_accumulation,
+        gradient_checkpointing=True,
+        gradient_checkpointing_kwargs={"use_reentrant": False},
+        max_grad_norm=0.3,
+        warmup_ratio=0.03,
+        max_steps=args.max_steps,
+        learning_rate=args.learning_rate,
+        logging_steps=max(1, args.max_steps // 20),
+        save_strategy="steps",
+        optim="adamw_torch_fused",
+        weight_decay=0.001,
+        lr_scheduler_type="cosine",
+        seed=3407,
+        # VLM-specific settings (required for Unsloth)
+        remove_unused_columns=False,
+        dataset_text_field="",
+        dataset_kwargs={"skip_prepare_dataset": True},
+        max_length=args.max_seq_length,
+        # Logging
+        report_to="trackio",
+        run_name=f"gemma3-vlm-{args.max_steps}steps",
+    )
+
+    trainer = SFTTrainer(
+        model=model,
+        train_dataset=dataset,
+        processing_class=processor.tokenizer,
+        data_collator=UnslothVisionDataCollator(model, processor),
+        args=training_config,
+    )
+
+    # 4. Train
+    print(f"\n[4/5] Training for {args.max_steps} steps...")
+    start = time.time()
+
+    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")
+
+    # 5. Save and push
+    print("\n[5/5] Saving model...")
+
+    # Save locally
+    model.save_pretrained(args.save_local)
+    processor.save_pretrained(args.save_local)
+    print(f"Saved locally to {args.save_local}/")
+
+    # Push to Hub
+    print(f"\nPushing to {args.output_repo}...")
+    model.push_to_hub(args.output_repo)
+    processor.push_to_hub(args.output_repo)
+    print(f"Model available at: https://huggingface.co/{args.output_repo}")
+
+    # Update model card metadata with dataset info
+    from huggingface_hub import metadata_update
+
+    metadata_update(args.output_repo, {"datasets": [args.dataset]}, overwrite=True)
+    print(f"  Model card updated with dataset: {args.dataset}")
+
+    print("\n" + "=" * 70)
+    print("Done!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 70)
+        print("Gemma 3 4B VLM Streaming 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("\nFeatures:")
+        print("  - ~60% less VRAM with Unsloth optimizations")
+        print("  - 2x faster training vs standard methods")
+        print("  - Trackio integration for monitoring")
+        print("  - Works with any VLM dataset in conversation format")
+        print("\nExample usage:")
+        print("\n  uv run sft-gemma3-vlm.py \\")
+        print("      --max-steps 500 \\")
+        print("      --output-repo your-username/vlm-finetuned")
+        print("\nHF Jobs example:")
+        print("\n  hf jobs uv run \\")
+        print(
+            "      https://huggingface.co/datasets/unsloth/jobs/raw/main/sft-gemma3-vlm.py \\"
+        )
+        print("      --flavor a100-large --secrets HF_TOKEN \\")
+        print("      -- --max-steps 500 --output-repo your-username/vlm-finetuned")
+        print("\nFor full help: uv run sft-gemma3-vlm.py --help")
+        print("=" * 70)
+        sys.exit(0)
+
+    main()

sft-lfm2.5.py

@@ -0,0 +1,539 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "unsloth",
+#     "datasets",
+#     "trl==0.22.2",
+#     "huggingface_hub[hf_transfer]",
+#     "trackio",
+#     "tensorboard",
+#     "transformers==4.57.3",
+# ]
+# ///
+"""
+Fine-tune LFM2.5-1.2B-Instruct (Liquid Foundation Model) using Unsloth optimizations.
+
+Uses Unsloth for ~60% less VRAM and 2x faster training.
+Supports epoch-based or step-based training with optional eval split.
+
+Epoch-based training (recommended for full datasets):
+    uv run sft-lfm2.5.py \
+        --dataset mlabonne/FineTome-100k \
+        --num-epochs 1 \
+        --eval-split 0.2 \
+        --output-repo your-username/lfm-finetuned
+
+Run on HF Jobs (1 epoch with eval):
+    hf jobs uv run sft-lfm2.5.py \
+        --flavor a10g-small --secrets HF_TOKEN --timeout 4h \
+        -- --dataset mlabonne/FineTome-100k \
+           --num-epochs 1 \
+           --eval-split 0.2 \
+           --output-repo your-username/lfm-finetuned
+
+Step-based training (for quick tests):
+    uv run sft-lfm2.5.py \
+        --dataset mlabonne/FineTome-100k \
+        --max-steps 500 \
+        --output-repo your-username/lfm-finetuned
+"""
+
+import argparse
+import logging
+import os
+import sys
+import time
+
+# Force unbuffered output for HF Jobs logs
+sys.stdout.reconfigure(line_buffering=True)
+sys.stderr.reconfigure(line_buffering=True)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+def check_cuda():
+    """Check CUDA availability and exit if not available."""
+    import torch
+
+    if not torch.cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        logger.error("Run on a machine with a CUDA-capable GPU or use HF Jobs:")
+        logger.error("  hf jobs uv run sft-lfm2.5.py --flavor a10g-small ...")
+        sys.exit(1)
+    logger.info(f"CUDA available: {torch.cuda.get_device_name(0)}")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Fine-tune LFM2.5-1.2B-Instruct with Unsloth",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Quick test run
+  uv run sft-lfm2.5.py \\
+      --dataset mlabonne/FineTome-100k \\
+      --max-steps 50 \\
+      --output-repo username/lfm-test
+
+  # Full training with eval
+  uv run sft-lfm2.5.py \\
+      --dataset mlabonne/FineTome-100k \\
+      --num-epochs 1 \\
+      --eval-split 0.2 \\
+      --output-repo username/lfm-finetuned
+
+  # With Trackio monitoring
+  uv run sft-lfm2.5.py \\
+      --dataset mlabonne/FineTome-100k \\
+      --num-epochs 1 \\
+      --output-repo username/lfm-finetuned \\
+      --trackio-space username/trackio
+        """,
+    )
+
+    # Model and data
+    parser.add_argument(
+        "--base-model",
+        default="LiquidAI/LFM2.5-1.2B-Instruct",
+        help="Base model (default: LiquidAI/LFM2.5-1.2B-Instruct)",
+    )
+    parser.add_argument(
+        "--dataset",
+        required=True,
+        help="Dataset in ShareGPT/conversation format (e.g., mlabonne/FineTome-100k)",
+    )
+    parser.add_argument(
+        "--output-repo",
+        required=True,
+        help="HF Hub repo to push model to (e.g., 'username/lfm-finetuned')",
+    )
+
+    # Training config
+    parser.add_argument(
+        "--num-epochs",
+        type=float,
+        default=None,
+        help="Number of epochs (default: None). Use instead of --max-steps.",
+    )
+    parser.add_argument(
+        "--max-steps",
+        type=int,
+        default=None,
+        help="Training steps (default: None). Use for quick tests or streaming.",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=2,
+        help="Per-device batch size (default: 2)",
+    )
+    parser.add_argument(
+        "--gradient-accumulation",
+        type=int,
+        default=4,
+        help="Gradient accumulation steps (default: 4). Effective batch = batch-size * this",
+    )
+    parser.add_argument(
+        "--learning-rate",
+        type=float,
+        default=2e-4,
+        help="Learning rate (default: 2e-4)",
+    )
+    parser.add_argument(
+        "--max-seq-length",
+        type=int,
+        default=2048,
+        help="Maximum sequence length (default: 2048)",
+    )
+
+    # LoRA config
+    parser.add_argument(
+        "--lora-r",
+        type=int,
+        default=16,
+        help="LoRA rank (default: 16). Higher = more capacity but more VRAM",
+    )
+    parser.add_argument(
+        "--lora-alpha",
+        type=int,
+        default=16,
+        help="LoRA alpha (default: 16). Same as r per Unsloth recommendation",
+    )
+
+    # Logging
+    parser.add_argument(
+        "--trackio-space",
+        default=None,
+        help="HF Space for Trackio dashboard (e.g., 'username/trackio')",
+    )
+    parser.add_argument(
+        "--run-name",
+        default=None,
+        help="Custom run name for Trackio (default: auto-generated)",
+    )
+    parser.add_argument(
+        "--save-local",
+        default="lfm-output",
+        help="Local directory to save model (default: lfm-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)",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=3407,
+        help="Random seed for reproducibility (default: 3407)",
+    )
+    parser.add_argument(
+        "--merge-model",
+        action="store_true",
+        default=False,
+        help="Merge LoRA weights into base model before uploading (larger file, easier to use)",
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    # Validate epochs/steps configuration
+    if not args.num_epochs and not args.max_steps:
+        args.num_epochs = 1
+        logger.info("Using default --num-epochs=1")
+
+    # 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("LFM2.5-1.2B Fine-tuning with Unsloth")
+    print("=" * 70)
+    print("\nConfiguration:")
+    print(f"  Base model:      {args.base_model}")
+    print(f"  Dataset:         {args.dataset}")
+    print(f"  Num samples:     {args.num_samples or 'all'}")
+    print(
+        f"  Eval split:      {args.eval_split if args.eval_split > 0 else '(disabled)'}"
+    )
+    print(f"  Seed:            {args.seed}")
+    print(f"  Training:        {duration_str}")
+    print(
+        f"  Batch size:      {args.batch_size} x {args.gradient_accumulation} = {args.batch_size * args.gradient_accumulation}"
+    )
+    print(f"  Learning rate:   {args.learning_rate}")
+    print(f"  LoRA rank:       {args.lora_r}")
+    print(f"  Max seq length:  {args.max_seq_length}")
+    print(f"  Output repo:     {args.output_repo}")
+    print(f"  Trackio space:   {args.trackio_space or '(not configured)'}")
+    print()
+
+    # Check CUDA before heavy imports
+    check_cuda()
+
+    # Enable fast transfers
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
+    # 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}"
+        )
+
+    # Import heavy dependencies
+    from unsloth import FastLanguageModel
+    from unsloth.chat_templates import standardize_data_formats, train_on_responses_only
+    from datasets import load_dataset
+    from trl import SFTTrainer, SFTConfig
+    from huggingface_hub import login
+
+    # Login to Hub
+    token = os.environ.get("HF_TOKEN") or os.environ.get("hfjob")
+    if token:
+        login(token=token)
+        logger.info("Logged in to Hugging Face Hub")
+    else:
+        logger.warning("HF_TOKEN not set - model upload may fail")
+
+    # 1. Load model
+    print("\n[1/5] Loading model...")
+    start = time.time()
+
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=args.base_model,
+        max_seq_length=args.max_seq_length,
+        load_in_4bit=False,
+        load_in_8bit=False,
+        load_in_16bit=True,
+        full_finetuning=False,
+    )
+
+    # Add LoRA adapters with LFM-specific target modules
+    model = FastLanguageModel.get_peft_model(
+        model,
+        r=args.lora_r,
+        target_modules=[
+            "q_proj",
+            "k_proj",
+            "v_proj",
+            "out_proj",
+            "in_proj",
+            "w1",
+            "w2",
+            "w3",
+        ],
+        lora_alpha=args.lora_alpha,
+        lora_dropout=0,
+        bias="none",
+        use_gradient_checkpointing="unsloth",
+        random_state=args.seed,
+        use_rslora=False,
+        loftq_config=None,
+    )
+    print(f"Model loaded in {time.time() - start:.1f}s")
+
+    # 2. Load and prepare dataset
+    print("\n[2/5] Loading dataset...")
+    start = time.time()
+
+    dataset = load_dataset(args.dataset, split="train")
+    print(f"  Dataset has {len(dataset)} total samples")
+
+    if args.num_samples:
+        dataset = dataset.select(range(min(args.num_samples, len(dataset))))
+        print(f"  Limited to {len(dataset)} samples")
+
+    # Auto-detect and normalize conversation column
+    for col in ["messages", "conversations", "conversation"]:
+        if col in dataset.column_names and isinstance(dataset[0][col], list):
+            if col != "conversations":
+                dataset = dataset.rename_column(col, "conversations")
+            break
+    dataset = standardize_data_formats(dataset)
+
+    # Apply chat template
+    def formatting_prompts_func(examples):
+        texts = tokenizer.apply_chat_template(
+            examples["conversations"],
+            tokenize=False,
+            add_generation_prompt=False,
+        )
+        # Remove BOS token to avoid duplicates
+        return {"text": [x.removeprefix(tokenizer.bos_token) for x in texts]}
+
+    dataset = dataset.map(formatting_prompts_func, batched=True)
+
+    # Split for evaluation if requested
+    if args.eval_split > 0:
+        split = dataset.train_test_split(test_size=args.eval_split, seed=args.seed)
+        train_data = split["train"]
+        eval_data = split["test"]
+        print(f"  Train: {len(train_data)} samples, Eval: {len(eval_data)} samples")
+    else:
+        train_data = dataset
+        eval_data = None
+
+    print(f"  Dataset ready in {time.time() - start:.1f}s")
+
+    # 3. Configure trainer
+    print("\n[3/5] Configuring trainer...")
+
+    # Calculate steps per epoch for logging/eval intervals
+    effective_batch = args.batch_size * args.gradient_accumulation
+    num_samples = len(train_data)
+    steps_per_epoch = num_samples // effective_batch
+
+    # Determine run name and logging steps
+    if args.run_name:
+        run_name = args.run_name
+    elif args.num_epochs:
+        run_name = f"lfm2.5-sft-{args.num_epochs}ep"
+    else:
+        run_name = f"lfm2.5-sft-{args.max_steps}steps"
+
+    if args.num_epochs:
+        logging_steps = max(1, steps_per_epoch // 10)
+        save_steps = max(1, steps_per_epoch // 4)
+    else:
+        logging_steps = max(1, args.max_steps // 20)
+        save_steps = max(1, args.max_steps // 4)
+
+    # Determine reporting backend
+    if args.trackio_space:
+        report_to = ["tensorboard", "trackio"]
+    else:
+        report_to = ["tensorboard"]
+
+    training_config = SFTConfig(
+        output_dir=args.save_local,
+        dataset_text_field="text",
+        per_device_train_batch_size=args.batch_size,
+        gradient_accumulation_steps=args.gradient_accumulation,
+        warmup_steps=5,
+        num_train_epochs=args.num_epochs if args.num_epochs else 1,
+        max_steps=args.max_steps if args.max_steps else -1,
+        learning_rate=args.learning_rate,
+        logging_steps=logging_steps,
+        optim="adamw_8bit",
+        weight_decay=0.01,
+        lr_scheduler_type="linear",
+        seed=args.seed,
+        max_length=args.max_seq_length,
+        report_to=report_to,
+        run_name=run_name,
+        push_to_hub=True,
+        hub_model_id=args.output_repo,
+        save_steps=save_steps,
+        save_total_limit=3,
+    )
+
+    # Add evaluation config if eval is enabled
+    if eval_data:
+        if args.num_epochs:
+            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")
+
+    trainer = SFTTrainer(
+        model=model,
+        tokenizer=tokenizer,
+        train_dataset=train_data,
+        eval_dataset=eval_data,
+        args=training_config,
+    )
+
+    # Train on responses only (mask user inputs)
+    trainer = train_on_responses_only(
+        trainer,
+        instruction_part="<|im_start|>user\n",
+        response_part="<|im_start|>assistant\n",
+    )
+
+    # 4. Train
+    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: {total_steps / train_time:.2f} steps/s")
+
+    # Print training 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...")
+        try:
+            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"  Warning: Eval loss is {ratio:.1f}x train loss - possible overfitting"
+                        )
+                    else:
+                        print(
+                            f"  Eval/train ratio: {ratio:.2f} - model generalizes well"
+                        )
+        except Exception as e:
+            print(f"  Warning: Final evaluation failed: {e}")
+            print("  Continuing to save model...")
+
+    # 5. Save and push
+    print("\n[5/5] Saving model...")
+
+    if args.merge_model:
+        print("Merging LoRA weights into base model...")
+        print(f"\nPushing merged model to {args.output_repo}...")
+        model.push_to_hub_merged(
+            args.output_repo,
+            tokenizer=tokenizer,
+            save_method="merged_16bit",
+        )
+        print(f"Merged model available at: https://huggingface.co/{args.output_repo}")
+    else:
+        model.save_pretrained(args.save_local)
+        tokenizer.save_pretrained(args.save_local)
+        print(f"Saved locally to {args.save_local}/")
+
+        print(f"\nPushing adapter to {args.output_repo}...")
+        model.push_to_hub(args.output_repo, tokenizer=tokenizer)
+        print(f"Adapter available at: https://huggingface.co/{args.output_repo}")
+
+    # Update model card metadata with dataset info
+    from huggingface_hub import metadata_update
+
+    metadata_update(args.output_repo, {"datasets": [args.dataset]}, overwrite=True)
+    print(f"  Model card updated with dataset: {args.dataset}")
+
+    print("\n" + "=" * 70)
+    print("Done!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        print("=" * 70)
+        print("LFM2.5-1.2B Fine-tuning with Unsloth")
+        print("=" * 70)
+        print("\nFine-tune Liquid Foundation Model with optional train/eval split.")
+        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("  - Trains only on assistant responses (masked user inputs)")
+        print("\nEpoch-based training:")
+        print("\n  uv run sft-lfm2.5.py \\")
+        print("      --dataset mlabonne/FineTome-100k \\")
+        print("      --num-epochs 1 \\")
+        print("      --eval-split 0.2 \\")
+        print("      --output-repo your-username/lfm-finetuned")
+        print("\nHF Jobs example:")
+        print("\n  hf jobs uv run sft-lfm2.5.py \\")
+        print("      --flavor a10g-small --secrets HF_TOKEN --timeout 4h \\")
+        print("      -- --dataset mlabonne/FineTome-100k \\")
+        print("         --num-epochs 1 \\")
+        print("         --eval-split 0.2 \\")
+        print("         --output-repo your-username/lfm-finetuned")
+        print("\nFor full help: uv run sft-lfm2.5.py --help")
+        print("=" * 70)
+        sys.exit(0)
+
+    main()

sft-qwen3-vl.py

@@ -0,0 +1,596 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "unsloth",
+#     "datasets",
+#     "trl==0.22.2",
+#     "huggingface_hub[hf_transfer]",
+#     "trackio",
+#     "tensorboard",
+#     "transformers==4.57.1",
+# ]
+# ///
+"""
+Fine-tune Qwen3-VL-8B Vision Language Model using Unsloth optimizations.
+
+Uses Unsloth for ~60% less VRAM and 2x faster training.
+Supports epoch-based or step-based training with optional eval split.
+
+Epoch-based training (recommended for full datasets):
+    uv run sft-qwen3-vl.py \
+        --num-epochs 1 \
+        --eval-split 0.2 \
+        --output-repo your-username/vlm-finetuned
+
+Run on HF Jobs (1 epoch with eval):
+    hf jobs uv run \
+        https://huggingface.co/datasets/unsloth/jobs/raw/main/sft-qwen3-vl.py \
+        --flavor a100-large --secrets HF_TOKEN --timeout 4h \
+        -- --num-epochs 1 --eval-split 0.2 --output-repo your-username/vlm-finetuned
+
+Step-based training (for streaming or quick tests):
+    uv run sft-qwen3-vl.py \
+        --streaming \
+        --max-steps 500 \
+        --output-repo your-username/vlm-finetuned
+
+Quick test with limited samples:
+    uv run sft-qwen3-vl.py \
+        --num-samples 500 \
+        --num-epochs 2 \
+        --eval-split 0.2 \
+        --output-repo your-username/vlm-test
+"""
+
+import argparse
+import logging
+import os
+import sys
+import time
+
+# Force unbuffered output for HF Jobs logs
+sys.stdout.reconfigure(line_buffering=True)
+sys.stderr.reconfigure(line_buffering=True)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+def check_cuda():
+    """Check CUDA availability and exit if not available."""
+    import torch
+
+    if not torch.cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        logger.error("Run on a machine with a CUDA-capable GPU or use HF Jobs:")
+        logger.error(
+            "  hf jobs uv run https://huggingface.co/datasets/unsloth/jobs/raw/main/sft-qwen3-vl.py --flavor a100-large ..."
+        )
+        sys.exit(1)
+    logger.info(f"CUDA available: {torch.cuda.get_device_name(0)}")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Fine-tune Qwen3-VL-8B with streaming datasets using Unsloth",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Quick test run
+  uv run sft-qwen3-vl.py \\
+      --max-steps 50 \\
+      --output-repo username/vlm-test
+
+  # Full training with Trackio monitoring
+  uv run sft-qwen3-vl.py \\
+      --max-steps 500 \\
+      --output-repo username/vlm-finetuned \\
+      --trackio-space username/trackio
+
+  # Custom dataset and model
+  uv run sft-qwen3-vl.py \\
+      --base-model unsloth/Qwen3-VL-8B-Instruct-unsloth-bnb-4bit \\
+      --dataset your-username/your-vlm-dataset \\
+      --max-steps 1000 \\
+      --output-repo username/custom-vlm
+        """,
+    )
+
+    # Model and data
+    parser.add_argument(
+        "--base-model",
+        default="unsloth/Qwen3-VL-8B-Instruct-unsloth-bnb-4bit",
+        help="Base VLM model (default: unsloth/Qwen3-VL-8B-Instruct-unsloth-bnb-4bit)",
+    )
+    parser.add_argument(
+        "--dataset",
+        default="davanstrien/iconclass-vlm-sft",
+        help="Dataset with 'images' and 'messages' columns (default: davanstrien/iconclass-vlm-sft)",
+    )
+    parser.add_argument(
+        "--output-repo",
+        required=True,
+        help="HF Hub repo to push model to (e.g., 'username/vlm-finetuned')",
+    )
+
+    # 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=None,
+        help="Training steps (default: None). Required for streaming mode, optional otherwise.",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=2,
+        help="Per-device batch size (default: 2)",
+    )
+    parser.add_argument(
+        "--gradient-accumulation",
+        type=int,
+        default=4,
+        help="Gradient accumulation steps (default: 4). Effective batch = batch-size * this",
+    )
+    parser.add_argument(
+        "--learning-rate",
+        type=float,
+        default=2e-4,
+        help="Learning rate (default: 2e-4)",
+    )
+    parser.add_argument(
+        "--max-seq-length",
+        type=int,
+        default=2048,
+        help="Maximum sequence length (default: 2048)",
+    )
+
+    # LoRA config
+    parser.add_argument(
+        "--lora-r",
+        type=int,
+        default=16,
+        help="LoRA rank (default: 16). Higher = more capacity but more VRAM",
+    )
+    parser.add_argument(
+        "--lora-alpha",
+        type=int,
+        default=16,
+        help="LoRA alpha (default: 16). Same as r per Unsloth notebook",
+    )
+
+    # Logging
+    parser.add_argument(
+        "--trackio-space",
+        default=None,
+        help="HF Space for Trackio dashboard (e.g., 'username/trackio')",
+    )
+    parser.add_argument(
+        "--run-name",
+        default=None,
+        help="Custom run name for Trackio (default: auto-generated from steps/epochs)",
+    )
+    parser.add_argument(
+        "--save-local",
+        default="vlm-qwen3-output",
+        help="Local directory to save model (default: vlm-qwen3-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.",
+    )
+    parser.add_argument(
+        "--merge-model",
+        action="store_true",
+        default=False,
+        help="Merge LoRA weights into base model before uploading (larger file, easier to use)",
+    )
+
+    return parser.parse_args()
+
+
+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("Qwen3-VL-8B 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"  Training:        {duration_str}")
+    print(
+        f"  Batch size:      {args.batch_size} x {args.gradient_accumulation} = {args.batch_size * args.gradient_accumulation}"
+    )
+    print(f"  Learning rate:   {args.learning_rate}")
+    print(f"  LoRA rank:       {args.lora_r}")
+    print(f"  Output repo:     {args.output_repo}")
+    print(f"  Trackio space:   {args.trackio_space or '(not configured)'}")
+    print()
+
+    # Check CUDA before heavy imports
+    check_cuda()
+
+    # Enable fast transfers
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+
+    # 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}"
+        )
+
+    # Import heavy dependencies (note: import from unsloth.trainer for VLM)
+    from unsloth import FastVisionModel
+    from unsloth.trainer import UnslothVisionDataCollator
+    from datasets import load_dataset
+    from trl import SFTTrainer, SFTConfig
+    from huggingface_hub import login
+
+    # Login to Hub
+    token = os.environ.get("HF_TOKEN")
+    if token:
+        login(token=token)
+        logger.info("Logged in to Hugging Face Hub")
+    else:
+        logger.warning("HF_TOKEN not set - model upload may fail")
+
+    # 1. Load model (Qwen returns tokenizer, not processor)
+    print("\n[1/5] Loading model...")
+    start = time.time()
+
+    model, tokenizer = FastVisionModel.from_pretrained(
+        args.base_model,
+        load_in_4bit=True,
+        use_gradient_checkpointing="unsloth",
+    )
+
+    model = FastVisionModel.get_peft_model(
+        model,
+        finetune_vision_layers=True,
+        finetune_language_layers=True,
+        finetune_attention_modules=True,
+        finetune_mlp_modules=True,
+        r=args.lora_r,
+        lora_alpha=args.lora_alpha,
+        lora_dropout=0,
+        bias="none",
+        random_state=3407,
+        use_rslora=False,
+        loftq_config=None,
+    )
+    print(f"Model loaded in {time.time() - start:.1f}s")
+
+    # 2. Load dataset (streaming or non-streaming)
+    print(
+        f"\n[2/5] Loading dataset ({'streaming' if args.streaming else 'non-streaming'})..."
+    )
+    start = time.time()
+
+    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 = split["train"]
+            eval_data = split["test"]
+            print(f"  Train: {len(train_data)} samples, Eval: {len(eval_data)} samples")
+        else:
+            train_data = dataset
+            eval_data = None
+
+        print(f"  Dataset ready in {time.time() - start:.1f}s")
+
+    # 3. Configure trainer
+    print("\n[3/5] Configuring trainer...")
+
+    # Enable training mode
+    FastVisionModel.for_training(model)
+
+    # Calculate steps per epoch for logging/eval intervals
+    effective_batch = args.batch_size * args.gradient_accumulation
+    num_samples = (
+        len(train_data) if hasattr(train_data, "__len__") else (args.num_samples or 500)
+    )
+    steps_per_epoch = num_samples // effective_batch
+
+    # Determine run name and logging steps
+    if args.run_name:
+        run_name = args.run_name
+    elif args.num_epochs:
+        run_name = f"qwen3-vl-sft-{args.num_epochs}ep"
+    else:
+        run_name = f"qwen3-vl-sft-{args.max_steps}steps"
+
+    if args.num_epochs:
+        logging_steps = max(1, steps_per_epoch // 10)  # ~10 logs per epoch
+        save_steps = max(1, steps_per_epoch // 4)  # ~4 saves per epoch
+    else:
+        logging_steps = max(1, args.max_steps // 20)
+        save_steps = max(1, args.max_steps // 4)  # ~4 saves per run
+
+    # Determine reporting backend
+    if args.trackio_space:
+        report_to = ["tensorboard", "trackio"]
+    else:
+        report_to = ["tensorboard"]
+
+    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)
+        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=logging_steps,
+        optim="adamw_8bit",  # Per notebook
+        weight_decay=0.001,
+        lr_scheduler_type="cosine" if args.num_epochs else "linear",
+        seed=args.seed,
+        # VLM-specific settings (required for Unsloth)
+        remove_unused_columns=False,
+        dataset_text_field="",
+        dataset_kwargs={"skip_prepare_dataset": True},
+        max_length=args.max_seq_length,
+        # Logging - always use tensorboard for reliable logs
+        report_to=report_to,
+        run_name=run_name,
+        # Push checkpoints to Hub frequently
+        push_to_hub=True,
+        hub_model_id=args.output_repo,
+        save_steps=save_steps,
+        save_total_limit=3,  # Keep last 3 checkpoints
+    )
+
+    # Add evaluation config if eval is enabled
+    if eval_data:
+        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(
+        model=model,
+        tokenizer=tokenizer,  # Full processor, not processor.tokenizer
+        data_collator=UnslothVisionDataCollator(
+            model,
+            tokenizer,
+            train_on_responses_only=True,
+            instruction_part="<|im_start|>user\n",
+            response_part="<|im_start|>assistant\n",
+        ),
+        train_dataset=train_data,
+        eval_dataset=eval_data,  # None if no eval
+        args=training_config,
+    )
+
+    # 4. Train
+    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: {total_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...")
+        try:
+            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"  Warning: Eval loss is {ratio:.1f}x train loss - possible overfitting"
+                        )
+                    else:
+                        print(
+                            f"  Eval/train ratio: {ratio:.2f} - model generalizes well"
+                        )
+        except Exception as e:
+            print(f"  Warning: Final evaluation failed: {e}")
+            print("  Continuing to save model...")
+
+    # 5. Save and push
+    print("\n[5/5] Saving model...")
+
+    if args.merge_model:
+        # Merge LoRA weights and push full model
+        print("Merging LoRA weights into base model...")
+        print(f"\nPushing merged model to {args.output_repo}...")
+        model.push_to_hub_merged(
+            args.output_repo,
+            tokenizer=tokenizer,
+            save_method="merged_16bit",
+        )
+        print(f"Merged model available at: https://huggingface.co/{args.output_repo}")
+    else:
+        # Save adapter only (smaller, requires base model to use)
+        model.save_pretrained(args.save_local)
+        tokenizer.save_pretrained(args.save_local)
+        print(f"Saved locally to {args.save_local}/")
+
+        print(f"\nPushing adapter to {args.output_repo}...")
+        model.push_to_hub(args.output_repo, tokenizer=tokenizer)
+        print(f"Adapter available at: https://huggingface.co/{args.output_repo}")
+
+    # Update model card metadata with dataset info
+    from huggingface_hub import metadata_update
+
+    metadata_update(args.output_repo, {"datasets": [args.dataset]}, overwrite=True)
+    print(f"  Model card updated with dataset: {args.dataset}")
+
+    print("\n" + "=" * 70)
+    print("Done!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    # Show example usage if no arguments
+    if len(sys.argv) == 1:
+        print("=" * 70)
+        print("Qwen3-VL-8B Fine-tuning with Unsloth")
+        print("=" * 70)
+        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("  - Epoch-based or step-based training")
+        print("  - Optional evaluation to detect overfitting")
+        print("  - Trackio integration for monitoring")
+        print("\nEpoch-based training (recommended for full datasets):")
+        print("\n  uv run sft-qwen3-vl.py \\")
+        print("      --num-epochs 1 \\")
+        print("      --eval-split 0.2 \\")
+        print("      --output-repo your-username/vlm-finetuned")
+        print("\nHF Jobs example (1 epoch with eval):")
+        print("\n  hf jobs uv run \\")
+        print(
+            "      https://huggingface.co/datasets/unsloth/jobs/raw/main/sft-qwen3-vl.py \\"
+        )
+        print("      --flavor a100-large --secrets HF_TOKEN --timeout 4h \\")
+        print(
+            "      -- --num-epochs 1 --eval-split 0.2 --output-repo your-username/vlm-finetuned"
+        )
+        print("\nStep-based training (for streaming or quick tests):")
+        print("\n  uv run sft-qwen3-vl.py \\")
+        print("      --streaming \\")
+        print("      --max-steps 500 \\")
+        print("      --output-repo your-username/vlm-finetuned")
+        print("\nFor full help: uv run sft-qwen3-vl.py --help")
+        print("=" * 70)
+        sys.exit(0)
+
+    main()