# /// 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", # "trackio", # ] # /// """ 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 # 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 \ --dataset-id HuggingFaceM4/FineVision \ --subset iam \ --hub-model-id username/lightonocr-iam \ --push-to-hub \ --eval-samples 100 # Run on HF Jobs with GPU and streaming hf jobs run --gpu l4x1 \ uv run lightonocr-finetune.py \ --dataset-id custom/large-ocr-dataset \ --output-dir ./custom-ocr \ --streaming \ --epochs 3 """ import argparse import logging import os import sys from datetime import datetime from pathlib import Path from typing import Dict, Optional import torch from datasets import load_dataset from huggingface_hub import login from jiwer import cer, wer 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__) 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 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 not batch_images: 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", 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 """ model.eval() predictions = [] ground_truths = [] logger.info(f"Evaluating {description} on {num_samples} samples...") # 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 ] # 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 ) actual_samples = len(predictions) logger.info( f"CER: {cer_score:.2f}% | WER: {wer_score:.2f}% | Perfect: {perfect_matches}/{actual_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": actual_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" ) # 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", 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") parser.add_argument( "--max-steps", type=int, help="Maximum number of training steps (auto-calculated for streaming if not specified)" ) 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}") 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) # 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}") 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", is_streaming=False, # Test dataset is never streamed ) torch.cuda.empty_cache() # Prepare data collator data_collator = OCRDataCollator( 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 # 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)))) # 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) 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}") 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", is_streaming=False, # Test dataset is never streamed ) # 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(" # 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 --streaming --output-dir ./model" ) sys.exit(0) main()