Add LightOnOCR fine-tuning script for OCR datasets

lightonocr-finetune.py

@@ -0,0 +1,829 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "torch>=2.0.0",
+#     "datasets>=2.14.0",
+#     "accelerate>=0.24.0",
+#     "huggingface-hub",
+#     "pillow>=12.0.0",
+#     "jiwer>=3.0.0",
+#     "tqdm>=4.65.0",
+#     "transformers @ git+https://github.com/baptiste-aubertin/transformers.git@main",
+# ]
+# ///
+
+"""
+Fine-tune LightOnOCR on OCR datasets.
+
+LightOnOCR is an end-to-end trainable vision-language model specifically designed for OCR tasks.
+This script enables fine-tuning on custom datasets for improved performance on specific domains,
+languages, or document types.
+
+Examples:
+    # Basic fine-tuning on IAM handwriting dataset
+    uv run lightonocr-finetune.py \
+        --dataset-id HuggingFaceM4/FineVision \
+        --subset iam \
+        --output-dir ./lightonocr-iam \
+        --epochs 2
+
+    # Fine-tune with frozen language model to save memory
+    uv run lightonocr-finetune.py \
+        --dataset-id HuggingFaceM4/FineVision \
+        --subset olmOCR-mix-0225-documents \
+        --output-dir ./lightonocr-docs \
+        --freeze-language \
+        --batch-size 8
+
+    # Push to Hub with evaluation metrics
+    uv run lightonocr-finetune.py \
+        --dataset-id HuggingFaceM4/FineVision \
+        --subset iam \
+        --hub-model-id username/lightonocr-iam \
+        --push-to-hub \
+        --eval-samples 100
+
+    # Run on HF Jobs with GPU
+    hf jobs run --gpu l4x1 \
+        uv run lightonocr-finetune.py \
+        --dataset-id custom/ocr-dataset \
+        --output-dir ./custom-ocr \
+        --epochs 3
+"""
+
+import argparse
+import json
+import logging
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import torch
+from datasets import load_dataset, DatasetDict
+from huggingface_hub import HfApi, login
+from jiwer import cer, wer
+from PIL import Image
+from tqdm import tqdm
+from transformers import (
+    AutoProcessor,
+    LightOnOCRForConditionalGeneration,
+    Trainer,
+    TrainingArguments,
+)
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# Constants for the assistant pattern in chat template
+ASSISTANT_START_PATTERN = [151645, 1699, 151644, 77091, 1699]
+DEFAULT_MAX_LENGTH = 1024
+DEFAULT_LONGEST_EDGE = 700
+
+
+class OCRDataCollator:
+    """Data collator for OCR fine-tuning."""
+
+    def __init__(
+        self,
+        processor,
+        max_length=DEFAULT_MAX_LENGTH,
+        longest_edge=DEFAULT_LONGEST_EDGE,
+    ):
+        self.processor = processor
+        self.max_length = max_length
+        self.longest_edge = longest_edge
+
+    def __call__(self, examples):
+        batch_messages = []
+        batch_images = []
+
+        for example in examples:
+            example_images = example["images"]
+            example_texts = example["texts"]
+
+            # Validate single image/text per example
+            if len(example_images) != 1 or len(example_texts) != 1:
+                logger.warning(
+                    f"Skipping example with {len(example_images)} images and {len(example_texts)} texts"
+                )
+                continue
+
+            image = example_images[0].convert("RGB")
+            batch_images.append(image)
+
+            # Extract assistant text from conversation
+            conversation = example_texts[0]
+            assistant_text = conversation.get("assistant", "").strip()
+
+            messages = [
+                {"role": "user", "content": [{"type": "image"}]},
+                {
+                    "role": "assistant",
+                    "content": [{"type": "text", "text": assistant_text}],
+                },
+            ]
+            batch_messages.append(messages)
+
+        if len(batch_images) == 0:
+            return None
+
+        # Apply chat template
+        texts = [
+            self.processor.apply_chat_template(
+                messages, tokenize=False, add_generation_prompt=False
+            )
+            for messages in batch_messages
+        ]
+
+        # Process inputs
+        inputs = self.processor(
+            text=texts,
+            images=batch_images,
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=self.max_length,
+            size={"longest_edge": self.longest_edge},
+        )
+
+        # Create labels (mask prompt, train only on assistant response)
+        labels = inputs["input_ids"].clone()
+        pad_token_id = self.processor.tokenizer.pad_token_id
+
+        for i in range(len(labels)):
+            full_ids = inputs["input_ids"][i].tolist()
+
+            # Find where assistant content starts
+            assistant_content_start = None
+
+            # Try the standard pattern: <|im_end|>\n<|im_start|>assistant\n
+            for idx in range(len(full_ids) - len(ASSISTANT_START_PATTERN)):
+                if (
+                    full_ids[idx : idx + len(ASSISTANT_START_PATTERN)]
+                    == ASSISTANT_START_PATTERN
+                ):
+                    assistant_content_start = idx + len(ASSISTANT_START_PATTERN)
+                    break
+
+            if assistant_content_start is None:
+                # Some samples may not have the exact pattern - this is expected
+                # The model will train on samples where the pattern is found
+                labels[i, :] = -100
+            else:
+                # Mask everything first
+                labels[i, :] = -100
+
+                # Unmask from assistant content start to end
+                for idx in range(assistant_content_start, len(full_ids)):
+                    if full_ids[idx] == pad_token_id:
+                        break
+                    labels[i, idx] = inputs["input_ids"][i, idx]
+
+            # Mask padding tokens
+            labels[i, inputs["input_ids"][i] == pad_token_id] = -100
+
+        inputs["labels"] = labels
+
+        # Convert to proper dtype
+        inputs["pixel_values"] = inputs["pixel_values"].to(torch.bfloat16)
+
+        return inputs
+
+
+def evaluate_model(
+    model,
+    processor,
+    dataset,
+    num_samples: int = 50,
+    batch_size: int = 8,
+    device: str = "cuda",
+    description: str = "Model",
+) -> Dict[str, float]:
+    """
+    Evaluate model on dataset and compute OCR metrics.
+
+    Returns:
+        Dictionary with CER, WER, and perfect match count
+    """
+    model.eval()
+    predictions = []
+    ground_truths = []
+
+    logger.info(f"Evaluating {description} on {num_samples} samples...")
+
+    # Process in batches
+    for start_idx in tqdm(range(0, min(num_samples, len(dataset)), batch_size)):
+        end_idx = min(start_idx + batch_size, num_samples, len(dataset))
+        batch_samples = [dataset[i] for i in range(start_idx, end_idx)]
+
+        batch_images = [[s["images"][0]] for s in batch_samples]
+        batch_ground_truths = [
+            s["texts"][0]["assistant"].strip() for s in batch_samples
+        ]
+
+        # Prepare inputs
+        messages = [{"role": "user", "content": [{"type": "image"}]}]
+        text = processor.apply_chat_template(
+            messages, tokenize=False, add_generation_prompt=True
+        )
+        texts = [text] * len(batch_images)
+
+        inputs = processor(
+            text=texts,
+            images=batch_images,
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=DEFAULT_MAX_LENGTH,
+            size={"longest_edge": DEFAULT_LONGEST_EDGE},
+        ).to(device)
+        inputs["pixel_values"] = inputs["pixel_values"].to(torch.bfloat16)
+
+        # Generate predictions
+        with torch.no_grad():
+            outputs = model.generate(**inputs, max_new_tokens=512, do_sample=True)
+
+        input_length = inputs["input_ids"].shape[1]
+        generated_ids = outputs[:, input_length:]
+        batch_predictions = processor.batch_decode(
+            generated_ids, skip_special_tokens=True
+        )
+        batch_predictions = [p.strip() for p in batch_predictions]
+
+        predictions.extend(batch_predictions)
+        ground_truths.extend(batch_ground_truths)
+
+    # Compute metrics
+    cer_score = cer(ground_truths, predictions) * 100
+    wer_score = wer(ground_truths, predictions) * 100
+    perfect_matches = sum(
+        1 for pred, gt in zip(predictions, ground_truths) if pred == gt
+    )
+
+    logger.info(
+        f"CER: {cer_score:.2f}% | WER: {wer_score:.2f}% | Perfect: {perfect_matches}/{num_samples}"
+    )
+
+    # Show a few examples
+    for i in range(min(3, len(predictions))):
+        match = "✅" if predictions[i] == ground_truths[i] else "❌"
+        logger.info(
+            f"{match} Sample {i + 1}: '{predictions[i][:50]}...' vs '{ground_truths[i][:50]}...'"
+        )
+
+    return {
+        "cer": cer_score,
+        "wer": wer_score,
+        "perfect_matches": perfect_matches,
+        "total_samples": num_samples,
+    }
+
+
+def create_model_card_content(
+    model_id: str,
+    dataset_id: str,
+    subset: Optional[str],
+    base_metrics: Dict[str, float],
+    finetuned_metrics: Dict[str, float],
+    training_args: TrainingArguments,
+    freeze_config: Dict[str, bool],
+) -> str:
+    """Generate model card content with training details and metrics."""
+
+    # Calculate improvements
+    cer_improvement = base_metrics["cer"] - finetuned_metrics["cer"]
+    wer_improvement = base_metrics["wer"] - finetuned_metrics["wer"]
+    perfect_improvement = (
+        finetuned_metrics["perfect_matches"] - base_metrics["perfect_matches"]
+    )
+
+    # Determine which components were frozen
+    frozen_components = [comp for comp, is_frozen in freeze_config.items() if is_frozen]
+    frozen_str = (
+        ", ".join(frozen_components) if frozen_components else "None (full fine-tuning)"
+    )
+
+    dataset_str = f"{dataset_id}/{subset}" if subset else dataset_id
+
+    content = f"""---
+license: mit
+tags:
+- vision
+- ocr
+- document-understanding
+- transformers
+base_model: lightonai/LightOnOCR-1B-1025
+datasets:
+- {dataset_id}
+metrics:
+- cer
+- wer
+library_name: transformers
+---
+
+# {model_id.split("/")[-1]}
+
+This model is a fine-tuned version of [LightOnOCR-1B-1025](https://huggingface.co/lightonai/LightOnOCR-1B-1025) on the {dataset_str} dataset.
+
+## Model Description
+
+LightOnOCR is an end-to-end trainable vision-language model specifically designed for OCR tasks. This fine-tuned version has been optimized for improved performance on the target dataset.
+
+## Training Details
+
+### Dataset
+- **Source**: {dataset_str}
+- **Training samples**: {training_args.num_train_epochs * (training_args.per_device_train_batch_size * training_args.gradient_accumulation_steps)}
+- **Validation samples**: Used for model selection
+
+### Training Configuration
+- **Epochs**: {training_args.num_train_epochs}
+- **Batch size**: {training_args.per_device_train_batch_size} (effective: {training_args.per_device_train_batch_size * training_args.gradient_accumulation_steps})
+- **Learning rate**: {training_args.learning_rate}
+- **Frozen components**: {frozen_str}
+- **Hardware**: GPU with mixed precision (bf16)
+
+## Evaluation Results
+
+### Performance Comparison
+
+| Metric | Base Model | Fine-tuned | Improvement |
+|--------|------------|------------|-------------|
+| **CER (%)** | {base_metrics["cer"]:.2f} | {finetuned_metrics["cer"]:.2f} | {cer_improvement:+.2f} |
+| **WER (%)** | {base_metrics["wer"]:.2f} | {finetuned_metrics["wer"]:.2f} | {wer_improvement:+.2f} |
+| **Perfect Matches** | {base_metrics["perfect_matches"]}/{base_metrics["total_samples"]} | {finetuned_metrics["perfect_matches"]}/{finetuned_metrics["total_samples"]} | {perfect_improvement:+d} |
+
+*Lower is better for CER and WER. Evaluation performed on {finetuned_metrics["total_samples"]} test samples.*
+
+## Usage
+
+```python
+from transformers import AutoProcessor, LightOnOCRForConditionalGeneration
+from PIL import Image
+import torch
+
+# Load model and processor
+model = LightOnOCRForConditionalGeneration.from_pretrained(
+    "{model_id}",
+    torch_dtype=torch.bfloat16,
+    device_map="auto"
+)
+processor = AutoProcessor.from_pretrained("{model_id}")
+
+# Prepare image
+image = Image.open("your_image.jpg").convert("RGB")
+
+# Create prompt
+messages = [
+    {{"role": "user", "content": [{{"type": "image"}}]}}
+]
+
+# Process and generate
+text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+inputs = processor(
+    text=[text],
+    images=[[image]],
+    return_tensors="pt",
+    max_length=1024
+).to(model.device)
+
+outputs = model.generate(**inputs, max_new_tokens=512)
+generated_text = processor.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
+print(generated_text)
+```
+
+## Training Script
+
+This model was trained using the UV Scripts training pipeline. To reproduce or further fine-tune:
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/transformers-training/raw/main/lightonocr-finetune.py \\
+    --dataset-id {dataset_id} \\
+    {"--subset " + subset if subset else ""} \\
+    --output-dir ./model \\
+    --epochs {training_args.num_train_epochs}
+```
+
+## Citation
+
+If you use this model, please cite:
+
+```bibtex
+@misc{{lightonocr2024,
+  title={{LightOnOCR: End-to-End Trainable OCR Model}},
+  author={{LightOn AI}},
+  year={{2024}},
+  url={{https://huggingface.co/blog/lightonai/lightonocr}}
+}}
+```
+
+## License
+
+This model is released under the MIT license.
+
+---
+
+*Generated on {datetime.now().strftime("%Y-%m-%d")} using [UV Scripts](https://huggingface.co/uv-scripts)*
+"""
+
+    return content
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Fine-tune LightOnOCR on OCR datasets",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    # Dataset arguments
+    parser.add_argument(
+        "--dataset-id",
+        type=str,
+        default="HuggingFaceM4/FineVision",
+        help="HuggingFace dataset ID",
+    )
+    parser.add_argument(
+        "--subset",
+        type=str,
+        default="iam",
+        choices=["iam", "olmOCR-mix-0225-books", "olmOCR-mix-0225-documents"],
+        help="Dataset subset to use (for FineVision)",
+    )
+    parser.add_argument(
+        "--train-split",
+        type=str,
+        default="train[:85%]",
+        help="Training split specification",
+    )
+    parser.add_argument(
+        "--val-split",
+        type=str,
+        default="train[85%:95%]",
+        help="Validation split specification",
+    )
+    parser.add_argument(
+        "--test-split", type=str, default="train[95%:]", help="Test split specification"
+    )
+
+    # Model arguments
+    parser.add_argument(
+        "--model-id",
+        type=str,
+        default="lightonai/LightOnOCR-1B-1025",
+        help="Base model ID",
+    )
+    parser.add_argument(
+        "--freeze-vision", action="store_true", help="Freeze vision encoder"
+    )
+    parser.add_argument(
+        "--freeze-language", action="store_true", help="Freeze language model"
+    )
+    parser.add_argument(
+        "--freeze-projection",
+        action="store_true",
+        help="Freeze vision projection layer",
+    )
+
+    # Training arguments
+    parser.add_argument(
+        "--output-dir", type=str, required=True, help="Directory to save the model"
+    )
+    parser.add_argument(
+        "--epochs", type=int, default=2, help="Number of training epochs"
+    )
+    parser.add_argument(
+        "--batch-size", type=int, default=4, help="Training batch size per device"
+    )
+    parser.add_argument(
+        "--gradient-accumulation",
+        type=int,
+        default=4,
+        help="Gradient accumulation steps",
+    )
+    parser.add_argument(
+        "--learning-rate", type=float, default=6e-5, help="Learning rate"
+    )
+    parser.add_argument(
+        "--warmup-steps", type=int, default=10, help="Number of warmup steps"
+    )
+    parser.add_argument(
+        "--eval-steps", type=int, default=50, help="Evaluation interval (in steps)"
+    )
+    parser.add_argument(
+        "--save-steps",
+        type=int,
+        default=500,
+        help="Save checkpoint interval (in steps)",
+    )
+    parser.add_argument(
+        "--max-length", type=int, default=1024, help="Maximum sequence length"
+    )
+    parser.add_argument(
+        "--longest-edge", type=int, default=700, help="Longest edge for image resizing"
+    )
+
+    # Evaluation arguments
+    parser.add_argument(
+        "--eval-samples", type=int, default=100, help="Number of samples for evaluation"
+    )
+    parser.add_argument(
+        "--eval-batch-size", type=int, default=8, help="Batch size for evaluation"
+    )
+    parser.add_argument(
+        "--skip-base-eval", action="store_true", help="Skip base model evaluation"
+    )
+
+    # Hub arguments
+    parser.add_argument(
+        "--hub-model-id", type=str, help="HuggingFace Hub model ID for pushing"
+    )
+    parser.add_argument(
+        "--push-to-hub", action="store_true", help="Push model to HuggingFace Hub"
+    )
+    parser.add_argument("--hf-token", type=str, help="HuggingFace API token")
+    parser.add_argument(
+        "--private", action="store_true", help="Make the model private on Hub"
+    )
+
+    # Other arguments
+    parser.add_argument(
+        "--max-samples", type=int, help="Limit number of training samples (for testing)"
+    )
+    parser.add_argument("--seed", type=int, default=42, help="Random seed")
+
+    args = parser.parse_args()
+
+    # Check GPU availability
+    if not torch.cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        logger.info("To run on HF Jobs with GPU:")
+        logger.info(
+            f"hf jobs run --gpu l4x1 uv run {__file__} --dataset-id {args.dataset_id} --output-dir {args.output_dir}"
+        )
+        sys.exit(1)
+
+    device = "cuda"
+    logger.info(f"Using GPU: {torch.cuda.get_device_name(0)}")
+
+    # Set environment variables for better performance
+    os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+    os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
+    torch.set_float32_matmul_precision("high")
+
+    # Login to HuggingFace if needed
+    if args.push_to_hub:
+        token = args.hf_token or os.environ.get("HF_TOKEN")
+        if token:
+            login(token=token)
+        else:
+            logger.error("HF_TOKEN required for push_to_hub")
+            sys.exit(1)
+
+    # Load dataset
+    logger.info(f"Loading dataset: {args.dataset_id}/{args.subset}")
+    train_ds = load_dataset(args.dataset_id, args.subset, split=args.train_split)
+    val_ds = load_dataset(args.dataset_id, args.subset, split=args.val_split)
+    test_ds = load_dataset(args.dataset_id, args.subset, split=args.test_split)
+
+    # Limit samples if requested
+    if args.max_samples:
+        train_ds = train_ds.select(range(min(args.max_samples, len(train_ds))))
+        logger.info(f"Limited training to {len(train_ds)} samples")
+
+    logger.info(
+        f"Dataset sizes - Train: {len(train_ds)}, Val: {len(val_ds)}, Test: {len(test_ds)}"
+    )
+
+    # Load processor
+    logger.info(f"Loading processor from {args.model_id}")
+    processor = AutoProcessor.from_pretrained(args.model_id)
+    processor.tokenizer.padding_side = "left"
+
+    # Load model
+    logger.info(f"Loading model from {args.model_id}")
+    model = LightOnOCRForConditionalGeneration.from_pretrained(
+        args.model_id,
+        torch_dtype=torch.bfloat16,
+        attn_implementation="sdpa",
+        device_map="auto",
+    ).to(device)
+
+    # Freeze components as requested
+    freeze_config = {
+        "vision_encoder": args.freeze_vision,
+        "language_model": args.freeze_language,
+        "vision_projection": args.freeze_projection,
+    }
+
+    if args.freeze_vision:
+        for param in model.model.vision_encoder.parameters():
+            param.requires_grad = False
+        logger.info("Vision encoder frozen")
+
+    if args.freeze_language:
+        for param in model.model.language_model.parameters():
+            param.requires_grad = False
+        logger.info("Language model frozen")
+
+    if args.freeze_projection:
+        for param in model.model.vision_projection.parameters():
+            param.requires_grad = False
+        logger.info("Vision projection frozen")
+
+    # Count trainable parameters
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    logger.info(f"Total parameters: {total_params:,}")
+    logger.info(
+        f"Trainable parameters: {trainable_params:,} ({100 * trainable_params / total_params:.2f}%)"
+    )
+
+    # Evaluate base model
+    base_metrics = {
+        "cer": 0.0,
+        "wer": 0.0,
+        "perfect_matches": 0,
+        "total_samples": args.eval_samples,
+    }
+    if not args.skip_base_eval:
+        logger.info("\n" + "=" * 80)
+        logger.info("EVALUATING BASE MODEL")
+        logger.info("=" * 80)
+        base_metrics = evaluate_model(
+            model,
+            processor,
+            test_ds,
+            num_samples=args.eval_samples,
+            batch_size=args.eval_batch_size,
+            device=device,
+            description="Base model",
+        )
+        torch.cuda.empty_cache()
+
+    # Prepare data collator
+    data_collator = OCRDataCollator(
+        processor, max_length=args.max_length, longest_edge=args.longest_edge
+    )
+
+    # Setup training arguments
+    training_args = TrainingArguments(
+        output_dir=args.output_dir,
+        num_train_epochs=args.epochs,
+        per_device_train_batch_size=args.batch_size,
+        per_device_eval_batch_size=args.eval_batch_size,
+        gradient_accumulation_steps=args.gradient_accumulation,
+        learning_rate=args.learning_rate,
+        weight_decay=0.0,
+        logging_steps=50,
+        eval_strategy="steps",
+        eval_steps=args.eval_steps,
+        save_strategy="steps",
+        save_steps=args.save_steps,
+        save_total_limit=2,
+        load_best_model_at_end=True,
+        metric_for_best_model="eval_loss",
+        bf16=True,
+        fp16=False,
+        remove_unused_columns=False,
+        dataloader_pin_memory=False,
+        gradient_checkpointing=True,
+        optim="adamw_torch_fused" if torch.cuda.is_available() else "adamw_torch",
+        warmup_steps=args.warmup_steps,
+        lr_scheduler_type="linear",
+        push_to_hub=args.push_to_hub,
+        hub_model_id=args.hub_model_id,
+        hub_private_repo=args.private,
+    )
+
+    # Use smaller validation set for faster evaluation
+    val_ds_small = val_ds.select(range(min(100, len(val_ds))))
+
+    # Create trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_ds,
+        eval_dataset=val_ds_small,
+        data_collator=data_collator,
+    )
+
+    # Train
+    logger.info("\n" + "=" * 80)
+    logger.info("STARTING TRAINING")
+    logger.info("=" * 80)
+    logger.info(f"Training samples: {len(train_ds)}")
+    logger.info(f"Validation samples: {len(val_ds_small)}")
+    logger.info(f"Effective batch size: {args.batch_size * args.gradient_accumulation}")
+
+    trainer.train()
+
+    # Save model
+    logger.info("Saving model and processor...")
+    trainer.save_model(args.output_dir)
+    processor.save_pretrained(args.output_dir)
+
+    # Evaluate fine-tuned model
+    logger.info("\n" + "=" * 80)
+    logger.info("EVALUATING FINE-TUNED MODEL")
+    logger.info("=" * 80)
+    finetuned_metrics = evaluate_model(
+        model,
+        processor,
+        test_ds,
+        num_samples=args.eval_samples,
+        batch_size=args.eval_batch_size,
+        device=device,
+        description="Fine-tuned model",
+    )
+
+    # Show comparison
+    if not args.skip_base_eval:
+        logger.info("\n" + "=" * 80)
+        logger.info("PERFORMANCE COMPARISON")
+        logger.info("=" * 80)
+        logger.info(
+            f"{'Metric':<20} {'Base':<12} {'Fine-tuned':<12} {'Improvement':<12}"
+        )
+        logger.info("-" * 56)
+        logger.info(
+            f"{'CER (%)':<20} {base_metrics['cer']:<12.2f} {finetuned_metrics['cer']:<12.2f} {base_metrics['cer'] - finetuned_metrics['cer']:+.2f}"
+        )
+        logger.info(
+            f"{'WER (%)':<20} {base_metrics['wer']:<12.2f} {finetuned_metrics['wer']:<12.2f} {base_metrics['wer'] - finetuned_metrics['wer']:+.2f}"
+        )
+        logger.info(
+            f"{'Perfect Matches':<20} {base_metrics['perfect_matches']:<12} {finetuned_metrics['perfect_matches']:<12} {finetuned_metrics['perfect_matches'] - base_metrics['perfect_matches']:+d}"
+        )
+        logger.info("=" * 80)
+
+    # Create and save model card
+    if args.hub_model_id or args.push_to_hub:
+        model_id = args.hub_model_id or f"{args.output_dir.split('/')[-1]}"
+        logger.info("Creating model card with metrics...")
+
+        model_card_content = create_model_card_content(
+            model_id=model_id,
+            dataset_id=args.dataset_id,
+            subset=args.subset,
+            base_metrics=base_metrics,
+            finetuned_metrics=finetuned_metrics,
+            training_args=training_args,
+            freeze_config=freeze_config,
+        )
+
+        # Save model card
+        model_card_path = Path(args.output_dir) / "README.md"
+        model_card_path.write_text(model_card_content)
+        logger.info(f"Model card saved to {model_card_path}")
+
+        if args.push_to_hub:
+            logger.info(f"Pushing model to Hub: {args.hub_model_id}")
+            trainer.push_to_hub()
+            logger.info(
+                f"✅ Model available at: https://huggingface.co/{args.hub_model_id}"
+            )
+
+    logger.info("\n✅ Training complete!")
+    logger.info(f"Model saved to: {args.output_dir}")
+
+    # Print example command for inference
+    logger.info("\n" + "=" * 80)
+    logger.info("To use the fine-tuned model:")
+    logger.info("=" * 80)
+    logger.info(f"""
+from transformers import AutoProcessor, LightOnOCRForConditionalGeneration
+from PIL import Image
+
+model = LightOnOCRForConditionalGeneration.from_pretrained("{args.output_dir}")
+processor = AutoProcessor.from_pretrained("{args.output_dir}")
+# ... rest of inference code
+""")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        print("LightOnOCR Fine-tuning Script\n")
+        print("Examples:")
+        print("  # Basic fine-tuning:")
+        print(
+            "  uv run lightonocr-finetune.py --dataset-id HuggingFaceM4/FineVision --subset iam --output-dir ./model\n"
+        )
+        print("  # With frozen components:")
+        print(
+            "  uv run lightonocr-finetune.py --freeze-language --output-dir ./model\n"
+        )
+        print("  # Push to Hub:")
+        print(
+            "  uv run lightonocr-finetune.py --hub-model-id username/model --push-to-hub\n"
+        )
+        print("  # Run on HF Jobs:")
+        print(
+            "  hf jobs run --gpu l4x1 uv run lightonocr-finetune.py --output-dir ./model"
+        )
+        sys.exit(0)
+
+    main()