| --- |
| viewer: false |
| tags: |
| - uv-script |
| - training |
| - vlm |
| - unsloth |
| - iconclass |
| - fine-tuning |
| --- |
| |
| # VLM Training with Unsloth |
|
|
| Fine-tune Vision-Language Models efficiently using [Unsloth](https://github.com/unslothai/unsloth) - get 2x faster training with lower memory usage! |
|
|
| ## 🎨 Example: Iconclass VLM |
|
|
| This directory contains scripts for fine-tuning VLMs to generate [Iconclass](https://iconclass.org) metadata codes from artwork images. Iconclass is a hierarchical classification system used in art history and cultural heritage. |
|
|
| ### What You'll Train |
|
|
| Given an artwork image, the model outputs structured JSON: |
|
|
| ```json |
| { |
| "iconclass-codes": ["25H213", "25H216", "25I"] |
| } |
| ``` |
|
|
| Where codes represent: |
| - `25H213`: river |
| - `25H216`: waterfall |
| - `25I`: city-view with man-made constructions |
|
|
| ## 🚀 Quick Start |
|
|
| ### Option 1: Run on HF Jobs (Recommended) |
|
|
| ```bash |
| # Set your HF token |
| export HF_TOKEN=your_token_here |
| |
| # Submit training job |
| python submit_training_job.py |
| ``` |
|
|
| That's it! Your model will train on cloud GPUs and automatically push to the Hub. |
|
|
| ### Option 2: Run Locally (Requires GPU) |
|
|
| ```bash |
| # Install UV (if not already installed) |
| curl -LsSf https://astral.sh/uv/install.sh | sh |
| |
| # Run training |
| uv run iconclass-vlm-sft.py \ |
| --base-model Qwen/Qwen3-VL-8B-Instruct \ |
| --dataset davanstrien/iconclass-vlm-sft \ |
| --output-model your-username/iconclass-vlm |
| ``` |
|
|
| ### Option 3: Quick Test (100 steps) |
|
|
| ```bash |
| uv run iconclass-vlm-sft.py \ |
| --base-model Qwen/Qwen3-VL-8B-Instruct \ |
| --dataset davanstrien/iconclass-vlm-sft \ |
| --output-model your-username/iconclass-vlm-test \ |
| --max-steps 100 |
| ``` |
|
|
| ## 📋 Requirements |
|
|
| ### For HF Jobs |
| - Hugging Face account with Jobs access |
| - HF token with write permissions |
|
|
| ### For Local Training |
| - CUDA-capable GPU (A100 recommended, A10G works) |
| - 40GB+ VRAM for 8B models (with 4-bit quantization) |
| - Python 3.11+ |
| - [UV](https://docs.astral.sh/uv/) installed |
|
|
| ## 🎛️ Configuration |
|
|
| ### Quick Config via Python Script |
|
|
| Edit `submit_training_job.py`: |
|
|
| ```python |
| # Model and dataset |
| BASE_MODEL = "Qwen/Qwen3-VL-8B-Instruct" |
| DATASET = "davanstrien/iconclass-vlm-sft" |
| OUTPUT_MODEL = "your-username/iconclass-vlm" |
| |
| # Training settings |
| BATCH_SIZE = 2 |
| GRADIENT_ACCUMULATION = 8 |
| LEARNING_RATE = 2e-5 |
| MAX_STEPS = None # Auto-calculate for 1 epoch |
| |
| # LoRA settings |
| LORA_R = 16 |
| LORA_ALPHA = 32 |
| |
| # GPU |
| GPU_FLAVOR = "a100-large" # or "a100", "a10g-large" |
| ``` |
|
|
| ### Full CLI Options |
|
|
| ```bash |
| uv run iconclass-vlm-sft.py --help |
| ``` |
|
|
| Key arguments: |
|
|
| | Argument | Default | Description | |
| |----------|---------|-------------| |
| | `--base-model` | Required | Base VLM (e.g., Qwen/Qwen3-VL-8B-Instruct) | |
| | `--dataset` | Required | Training dataset on HF Hub | |
| | `--output-model` | Required | Where to push your model | |
| | `--lora-r` | 16 | LoRA rank (higher = more capacity) | |
| | `--lora-alpha` | 32 | LoRA alpha (usually 2×r) | |
| | `--learning-rate` | 2e-5 | Learning rate | |
| | `--batch-size` | 2 | Per-device batch size | |
| | `--gradient-accumulation` | 8 | Gradient accumulation steps | |
| | `--max-steps` | Auto | Total training steps | |
| | `--num-epochs` | 1.0 | Epochs (if max-steps not set) | |
|
|
| ## 🏗️ Architecture |
|
|
| ### What Makes This Fast? |
|
|
| 1. **Unsloth Optimizations**: 2x faster training through: |
| - Optimized CUDA kernels |
| - Better memory management |
| - Efficient gradient checkpointing |
|
|
| 2. **4-bit Quantization**: |
| - Loads model in 4-bit precision |
| - Dramatically reduces VRAM usage |
| - Minimal impact on quality with LoRA |
|
|
| 3. **LoRA (Low-Rank Adaptation)**: |
| - Only trains 0.1-1% of parameters |
| - Much faster than full fine-tuning |
| - Easy to merge back or share |
|
|
| ### Training Flow |
|
|
| ``` |
| Dataset (HF Hub) |
| ↓ |
| FastVisionModel.from_pretrained (4-bit) |
| ↓ |
| Apply LoRA adapters |
| ↓ |
| SFTTrainer (Unsloth-optimized) |
| ↓ |
| Push to Hub with model card |
| ``` |
|
|
| ## 📊 Expected Performance |
|
|
| ### Training Time (Qwen3-VL-8B on A100) |
|
|
| | Dataset Size | Batch Config | Time | Cost (est.) | |
| |--------------|--------------|------|-------------| |
| | 44K samples | BS=2, GA=8 | ~4h | $16 | |
| | 10K samples | BS=2, GA=8 | ~1h | $4 | |
| | 1K samples | BS=2, GA=8 | ~10min | $0.70 | |
|
|
| *BS = Batch Size, GA = Gradient Accumulation* |
|
|
| ### GPU Requirements |
|
|
| | Model Size | Min GPU | Recommended | VRAM Usage | |
| |------------|---------|-------------|------------| |
| | 3B-4B | A10G | A100 | ~20GB | |
| | 7B-8B | A100 | A100 | ~35GB | |
| | 13B+ | A100 (80GB) | A100 (80GB) | ~60GB | |
|
|
| ## 🔍 Monitoring Your Job |
|
|
| ### Via CLI |
|
|
| ```bash |
| # Check status |
| hfjobs status your-job-id |
| |
| # Stream logs |
| hfjobs logs your-job-id --follow |
| |
| # List all jobs |
| hfjobs list |
| ``` |
|
|
| ### Via Python |
|
|
| ```python |
| from huggingface_hub import HfApi |
| |
| api = HfApi() |
| job = api.get_job("your-job-id") |
| |
| print(job.status) |
| print(job.logs()) |
| ``` |
|
|
| ### Via Web |
|
|
| Your job URL: `https://huggingface.co/jobs/your-username/your-job-id` |
|
|
| ## 🎯 Using Your Fine-Tuned Model |
|
|
| ```python |
| from unsloth import FastVisionModel |
| from PIL import Image |
| |
| # Load your model |
| model, tokenizer = FastVisionModel.from_pretrained( |
| model_name="your-username/iconclass-vlm", |
| load_in_4bit=True, |
| max_seq_length=2048, |
| ) |
| FastVisionModel.for_inference(model) |
| |
| # Prepare input |
| image = Image.open("artwork.jpg") |
| prompt = "Extract ICONCLASS labels for this image." |
| |
| messages = [ |
| { |
| "role": "user", |
| "content": [ |
| {"type": "image"}, |
| {"type": "text", "text": prompt}, |
| ], |
| } |
| ] |
| |
| # Apply chat template |
| inputs = tokenizer.apply_chat_template( |
| messages, |
| add_generation_prompt=True, |
| return_tensors="pt", |
| ).to("cuda") |
| |
| # Generate |
| outputs = model.generate( |
| **inputs, |
| max_new_tokens=256, |
| temperature=0.7, |
| top_p=0.9, |
| ) |
| |
| response = tokenizer.decode(outputs[0], skip_special_tokens=True) |
| print(response) |
| # {"iconclass-codes": ["31A235", "31A24(+1)", "61B(+54)"]} |
| ``` |
|
|
| ## 📦 Files in This Directory |
|
|
| | File | Purpose | |
| |------|---------| |
| | `iconclass-vlm-sft.py` | Main training script (UV script) | |
| | `submit_training_job.py` | Helper to submit HF Jobs | |
| | `README.md` | This file | |
|
|
| ## 🛠️ Troubleshooting |
|
|
| ### Out of Memory? |
|
|
| Reduce batch size or increase gradient accumulation: |
| ```bash |
| --batch-size 1 --gradient-accumulation 16 |
| ``` |
|
|
| ### Training Too Slow? |
|
|
| Increase batch size if you have VRAM: |
| ```bash |
| --batch-size 4 --gradient-accumulation 4 |
| ``` |
|
|
| ### Model Not Learning? |
|
|
| Try adjusting learning rate: |
| ```bash |
| --learning-rate 5e-5 # Higher |
| --learning-rate 1e-5 # Lower |
| ``` |
|
|
| Or increase LoRA rank: |
| ```bash |
| --lora-r 32 --lora-alpha 64 |
| ``` |
|
|
| ### Jobs Failing? |
|
|
| Check logs: |
| ```bash |
| hfjobs logs your-job-id |
| ``` |
|
|
| Common issues: |
| - HF_TOKEN not set correctly |
| - Output model repo doesn't exist (create it first) |
| - GPU out of memory (reduce batch size) |
| |
| ## 🔗 Related Resources |
| |
| - **Unsloth**: https://github.com/unslothai/unsloth |
| - **Unsloth Docs**: https://docs.unsloth.ai/ |
| - **TRL**: https://github.com/huggingface/trl |
| - **HF Jobs**: https://huggingface.co/docs/hub/spaces-sdks-jobs |
| - **UV**: https://docs.astral.sh/uv/ |
| - **Iconclass**: https://iconclass.org |
| - **Blog Post**: https://danielvanstrien.xyz/posts/2025/iconclass-vlm-sft/ |
| |
| ## 💡 Tips |
| |
| 1. **Start Small**: Test with `--max-steps 100` before full training |
| 2. **Use Wandb**: Add `--report-to wandb` for better monitoring |
| 3. **Save Often**: Use `--save-steps 50` for checkpoints |
| 4. **Multiple GPUs**: Script automatically uses all available GPUs |
| 5. **Resume Training**: Load from checkpoint with `--resume-from-checkpoint` |
| |
| ## 📝 Citation |
| |
| If you use this training setup, please cite: |
| |
| ```bibtex |
| @misc{iconclass-vlm-training, |
| author = {Daniel van Strien}, |
| title = {Efficient VLM Fine-tuning with Unsloth for Art History}, |
| year = {2025}, |
| publisher = {GitHub}, |
| howpublished = {\url{https://github.com/davanstrien/uv-scripts}} |
| } |
| ``` |
| |
| --- |
| |
| Made with 🦥 [Unsloth](https://github.com/unslothai/unsloth) • |
| Powered by 🤖 [UV Scripts](https://huggingface.co/uv-scripts) |
| |
