Enhance LightOnOCR fine-tuning script with streaming support and memory optimizations

lightonocr-finetune.py

@@ -34,6 +34,15 @@ Examples:
         --output-dir ./lightonocr-docs \
         --freeze-language \
         --batch-size 8
+    
+    # Stream large datasets to reduce memory usage
+    uv run lightonocr-finetune.py \
+        --dataset-id HuggingFaceM4/FineVision \
+        --subset olmOCR-mix-0225-books \
+        --output-dir ./lightonocr-books \
+        --streaming \
+        --shuffle-buffer-size 10000 \
+        --max-train-samples 5000  # Will auto-calculate max-steps
 
     # Push to Hub with evaluation metrics
     uv run lightonocr-finetune.py \
@@ -43,28 +52,27 @@ Examples:
         --push-to-hub \
         --eval-samples 100
 
-    # Run on HF Jobs with GPU
+    # Run on HF Jobs with GPU and streaming
     hf jobs run --gpu l4x1 \
         uv run lightonocr-finetune.py \
-        --dataset-id custom/ocr-dataset \
+        --dataset-id custom/large-ocr-dataset \
         --output-dir ./custom-ocr \
+        --streaming \
         --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
+from typing import Dict, Optional
 
 import torch
-from datasets import load_dataset, DatasetDict
-from huggingface_hub import HfApi, login
+from datasets import load_dataset
+from huggingface_hub import login
 from jiwer import cer, wer
-from PIL import Image
 from tqdm import tqdm
 from transformers import (
     AutoProcessor,
@@ -78,6 +86,8 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
+os.environ["HF_XET_HIGH_PERFORMANCE"] = "1"
+
 # Constants for the assistant pattern in chat template
 ASSISTANT_START_PATTERN = [151645, 1699, 151644, 77091, 1699]
 DEFAULT_MAX_LENGTH = 1024
@@ -128,7 +138,7 @@ class OCRDataCollator:
             ]
             batch_messages.append(messages)
 
-        if len(batch_images) == 0:
+        if not batch_images:
             return None
 
         # Apply chat template
@@ -202,10 +212,21 @@ def evaluate_model(
     batch_size: int = 8,
     device: str = "cuda",
     description: str = "Model",
+    is_streaming: bool = False,
 ) -> Dict[str, float]:
     """
     Evaluate model on dataset and compute OCR metrics.
 
+    Args:
+        model: The model to evaluate
+        processor: The processor for the model
+        dataset: Dataset to evaluate on (can be streaming or regular)
+        num_samples: Number of samples to evaluate
+        batch_size: Batch size for evaluation
+        device: Device to run evaluation on
+        description: Description for logging
+        is_streaming: Whether the dataset is a streaming dataset
+
     Returns:
         Dictionary with CER, WER, and perfect match count
     """
@@ -215,47 +236,102 @@ def evaluate_model(
 
     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)
+    # Handle streaming datasets differently
+    if is_streaming:
+        # For streaming datasets, we take the first num_samples
+        samples_processed = 0
+        batch_samples = []
+
+        for sample in tqdm(dataset, total=num_samples, desc="Evaluating"):
+            if samples_processed >= num_samples:
+                break
+
+            batch_samples.append(sample)
+            samples_processed += 1
+
+            # Process when we have a full batch or reached the end
+            if len(batch_samples) == batch_size or samples_processed == num_samples:
+                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)
+                batch_samples = []
+    else:
+        # Original non-streaming evaluation
+        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
+            ]
 
-        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]
+            # 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)
+            predictions.extend(batch_predictions)
+            ground_truths.extend(batch_ground_truths)
 
     # Compute metrics
     cer_score = cer(ground_truths, predictions) * 100
@@ -264,8 +340,9 @@ def evaluate_model(
         1 for pred, gt in zip(predictions, ground_truths) if pred == gt
     )
 
+    actual_samples = len(predictions)
     logger.info(
-        f"CER: {cer_score:.2f}% | WER: {wer_score:.2f}% | Perfect: {perfect_matches}/{num_samples}"
+        f"CER: {cer_score:.2f}% | WER: {wer_score:.2f}% | Perfect: {perfect_matches}/{actual_samples}"
     )
 
     # Show a few examples
@@ -279,7 +356,7 @@ def evaluate_model(
         "cer": cer_score,
         "wer": wer_score,
         "perfect_matches": perfect_matches,
-        "total_samples": num_samples,
+        "total_samples": actual_samples,
     }
 
 
@@ -469,6 +546,24 @@ def main():
         "--test-split", type=str, default="train[95%:]", help="Test split specification"
     )
 
+    # Streaming arguments
+    parser.add_argument(
+        "--streaming",
+        action="store_true",
+        help="Use dataset streaming to reduce memory usage (Note: uses full training set, ignores train-split percentages)",
+    )
+    parser.add_argument(
+        "--shuffle-buffer-size",
+        type=int,
+        default=10000,
+        help="Buffer size for shuffling when using streaming (default: 10000)",
+    )
+    parser.add_argument(
+        "--max-train-samples",
+        type=int,
+        help="Maximum number of training samples when streaming (useful for quick experiments)",
+    )
+
     # Model arguments
     parser.add_argument(
         "--model-id",
@@ -554,6 +649,11 @@ def main():
         "--max-samples", type=int, help="Limit number of training samples (for testing)"
     )
     parser.add_argument("--seed", type=int, default=42, help="Random seed")
+    parser.add_argument(
+        "--max-steps",
+        type=int,
+        help="Maximum number of training steps (auto-calculated for streaming if not specified)"
+    )
 
     args = parser.parse_args()
 
@@ -585,18 +685,63 @@ def main():
 
     # 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")
+    if args.streaming:
+        logger.info("Using streaming mode for dataset loading")
+        # For streaming, we can only use "train" split, not percentage-based splits
+        # Load the full training set in streaming mode
+        train_ds = load_dataset(
+            args.dataset_id, args.subset, split="train", streaming=True
+        )
+
+        # For validation and test, we need to load a subset of the data
+        # We'll use the last 15% of the data for validation and test
+        # Load the full dataset for splitting into val/test
+        full_ds = load_dataset(args.dataset_id, args.subset, split="train")
+        total_size = len(full_ds)
 
-    logger.info(
-        f"Dataset sizes - Train: {len(train_ds)}, Val: {len(val_ds)}, Test: {len(test_ds)}"
-    )
+        # Calculate split indices
+        train_end = int(0.85 * total_size)
+        val_end = int(0.95 * total_size)
+
+        # Create validation and test splits
+        val_ds = full_ds.select(range(train_end, val_end))
+        test_ds = full_ds.select(range(val_end, total_size))
+
+        # Clean up the full dataset to save memory
+        del full_ds
+
+        # Apply shuffling with buffer for streaming dataset
+        train_ds = train_ds.shuffle(
+            seed=args.seed, buffer_size=args.shuffle_buffer_size
+        )
+
+        # Limit samples if requested (for streaming)
+        if args.max_samples or args.max_train_samples:
+            max_samples = args.max_samples or args.max_train_samples
+            train_ds = train_ds.take(max_samples)
+            logger.info(f"Limited training to {max_samples} samples (streaming mode)")
+
+        logger.info(
+            f"Dataset loaded - Training: streaming (full train set), Val: {len(val_ds)}, Test: {len(test_ds)}"
+        )
+        logger.info(
+            "Note: When streaming, using full training set. Use --max-train-samples to limit."
+        )
+    else:
+        # Original non-streaming loading
+        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 (non-streaming)
+        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}")
@@ -661,6 +806,7 @@ def main():
             batch_size=args.eval_batch_size,
             device=device,
             description="Base model",
+            is_streaming=False,  # Test dataset is never streamed
         )
         torch.cuda.empty_cache()
 
@@ -669,35 +815,68 @@ def main():
         processor, max_length=args.max_length, longest_edge=args.longest_edge
     )
 
+    # Calculate max_steps for streaming datasets
+    max_steps = None
+    if args.streaming:
+        if args.max_steps:
+            max_steps = args.max_steps
+            logger.info(f"Using user-specified max_steps: {max_steps}")
+        else:
+            # Estimate max_steps based on dataset size and batch configuration
+            if args.max_train_samples:
+                # Calculate based on limited samples
+                steps_per_epoch = args.max_train_samples // (args.batch_size * args.gradient_accumulation)
+                max_steps = steps_per_epoch * args.epochs
+                logger.info(f"Calculated max_steps from max_train_samples: {max_steps}")
+            else:
+                # Use a default reasonable value
+                # Approximate based on typical dataset sizes
+                # Default to 1000 steps per epoch as a reasonable estimate
+                max_steps = 1000 * args.epochs
+                logger.warning(
+                    f"Streaming mode: Using default max_steps={max_steps}. "
+                    f"Consider setting --max-steps or --max-train-samples for precise control."
+                )
+
     # 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,
-    )
+    # When streaming, use max_steps instead of num_train_epochs
+    training_args_dict = {
+        "output_dir": args.output_dir,
+        "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,
+    }
+    
+    # Add either max_steps or num_train_epochs based on streaming mode
+    if args.streaming:
+        training_args_dict["max_steps"] = max_steps
+        # Still set num_train_epochs for model card generation
+        training_args_dict["num_train_epochs"] = args.epochs
+    else:
+        training_args_dict["num_train_epochs"] = args.epochs
+    
+    training_args = TrainingArguments(**training_args_dict)
 
     # Use smaller validation set for faster evaluation
     val_ds_small = val_ds.select(range(min(100, len(val_ds))))
@@ -715,7 +894,13 @@ def main():
     logger.info("\n" + "=" * 80)
     logger.info("STARTING TRAINING")
     logger.info("=" * 80)
-    logger.info(f"Training samples: {len(train_ds)}")
+    if args.streaming:
+        logger.info(
+            f"Training samples: streaming mode (max: {args.max_train_samples or 'unlimited'})"
+        )
+        logger.info(f"Max steps: {max_steps}")
+    else:
+        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}")
 
@@ -738,6 +923,7 @@ def main():
         batch_size=args.eval_batch_size,
         device=device,
         description="Fine-tuned model",
+        is_streaming=False,  # Test dataset is never streamed
     )
 
     # Show comparison
@@ -816,13 +1002,17 @@ if __name__ == "__main__":
         print(
             "  uv run lightonocr-finetune.py --freeze-language --output-dir ./model\n"
         )
+        print("  # Stream large datasets (memory-efficient):")
+        print(
+            "  uv run lightonocr-finetune.py --streaming --shuffle-buffer-size 10000 --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"
+            "  hf jobs run --gpu l4x1 uv run lightonocr-finetune.py --streaming --output-dir ./model"
         )
         sys.exit(0)