Add Falcon OCR script (0.3B, falcon-perception engine)

New OCR script using tiiuae/Falcon-OCR with the optimized falcon-perception
inference engine (CUDA graphs + batched paged inference). Achieves 0.31 img/s
on L4, 0.53 img/s on L40S. Supports plain OCR and layout-aware extraction.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

README.md

@@ -7,7 +7,7 @@ tags: [uv-script, ocr, vision-language-model, document-processing, hf-jobs]
 
 > Part of [uv-scripts](https://huggingface.co/uv-scripts) - ready-to-run ML tools powered by UV and HuggingFace Jobs.
 
-19 OCR scripts covering models from 0.9B to 8B parameters. Pick a model, point at your dataset, get markdown — no setup required.
+20 OCR scripts covering models from 0.3B to 8B parameters. Pick a model, point at your dataset, get markdown — no setup required.
 
 ## 🚀 Quick Start
 
@@ -33,6 +33,7 @@ That's it! The script will:
 
 | Script | Model | Size | Backend | Notes |
 |--------|-------|------|---------|-------|
+| `falcon-ocr.py` | [Falcon-OCR](https://huggingface.co/tiiuae/Falcon-OCR) | 0.3B | falcon-perception | 80.3% olmOCR, layout-aware, Apache 2.0 |
 | `smoldocling-ocr.py` | [SmolDocling](https://huggingface.co/ds4sd/SmolDocling-256M-preview) | 256M | Transformers | DocTags structured output |
 | `glm-ocr.py` | [GLM-OCR](https://huggingface.co/zai-org/GLM-OCR) | 0.9B | vLLM | 94.62% OmniDocBench V1.5 |
 | `paddleocr-vl.py` | [PaddleOCR-VL](https://huggingface.co/PaddlePaddle/PaddleOCR-VL) | 0.9B | Transformers | 4 task modes (ocr/table/formula/chart) |

falcon-ocr.py

@@ -0,0 +1,445 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets",
+#     "huggingface-hub",
+#     "pillow",
+#     "torch>=2.5",
+#     "torchvision",
+#     "falcon-perception[ocr]",
+#     "tqdm",
+# ]
+# ///
+
+"""
+Convert document images to text using Falcon OCR with the falcon-perception engine.
+
+Uses the optimized OCRInferenceEngine with CUDA graphs and paged inference
+for much faster throughput than the raw transformers API.
+
+Features:
+- Compact: Only 0.3B parameters
+- Fast: Optimized inference with CUDA graphs
+- Multi-format: Plain text, LaTeX formulas, HTML tables
+- Layout-aware: Optional 2-stage pipeline (layout detection + per-region OCR)
+
+Model: tiiuae/Falcon-OCR
+Backend: falcon-perception (OCRInferenceEngine)
+License: Apache 2.0
+
+Examples:
+    # Basic text OCR
+    uv run falcon-ocr.py input-dataset output-dataset
+
+    # Layout-aware OCR
+    uv run falcon-ocr.py dense-docs output --task-mode layout
+
+    # Test with small sample
+    uv run falcon-ocr.py dataset test --max-samples 5 --shuffle
+
+    # Run on HF Jobs with GPU
+    hf jobs uv run --flavor l4x1 \\
+        -s HF_TOKEN \\
+        falcon-ocr.py \\
+        input-dataset output-dataset --max-samples 10
+"""
+
+import argparse
+import io
+import json
+import logging
+import os
+import sys
+import time
+from datetime import datetime
+from typing import Any, Dict, Union
+
+import torch
+from datasets import load_dataset
+from huggingface_hub import DatasetCard, login
+from PIL import Image
+from tqdm.auto import tqdm
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+MODEL_ID = "tiiuae/Falcon-OCR"
+
+TASK_MODES = {
+    "plain": "Full-page text extraction",
+    "layout": "Layout-aware OCR (region detection + per-region extraction)",
+}
+
+
+def check_cuda_availability():
+    if not torch.cuda.is_available():
+        logger.error("CUDA is not available. This script requires a GPU.")
+        logger.error("For cloud execution, use HF Jobs with --flavor l4x1 or similar.")
+        sys.exit(1)
+    else:
+        logger.info(f"CUDA is available. GPU: {torch.cuda.get_device_name(0)}")
+
+
+def prepare_image(image: Union[Image.Image, Dict[str, Any], str]) -> Image.Image:
+    if isinstance(image, Image.Image):
+        pil_img = image
+    elif isinstance(image, dict) and "bytes" in image:
+        pil_img = Image.open(io.BytesIO(image["bytes"]))
+    elif isinstance(image, str):
+        pil_img = Image.open(image)
+    else:
+        raise ValueError(f"Unsupported image type: {type(image)}")
+    return pil_img.convert("RGB")
+
+
+def create_dataset_card(
+    source_dataset: str,
+    task_mode: str,
+    num_samples: int,
+    processing_time: str,
+    image_column: str = "image",
+    split: str = "train",
+) -> str:
+    task_description = TASK_MODES[task_mode]
+    return f"""---
+tags:
+- ocr
+- document-processing
+- falcon-ocr
+- {task_mode}
+- uv-script
+- generated
+---
+
+# Document Processing using Falcon OCR ({task_mode} mode)
+
+This dataset contains OCR results from images in [{source_dataset}](https://huggingface.co/datasets/{source_dataset}) using [Falcon OCR](https://huggingface.co/tiiuae/Falcon-OCR), a 0.3B early-fusion vision-language model.
+
+## Processing Details
+
+- **Source Dataset**: [{source_dataset}](https://huggingface.co/datasets/{source_dataset})
+- **Model**: [{MODEL_ID}](https://huggingface.co/{MODEL_ID})
+- **Task Mode**: `{task_mode}` - {task_description}
+- **Number of Samples**: {num_samples:,}
+- **Processing Time**: {processing_time}
+- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
+- **Backend**: falcon-perception (OCRInferenceEngine)
+
+## Reproduction
+
+```bash
+uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/falcon-ocr.py \\
+    {source_dataset} \\
+    <output-dataset> \\
+    --task-mode {task_mode} \\
+    --image-column {image_column}
+```
+
+Generated with [UV Scripts](https://huggingface.co/uv-scripts)
+"""
+
+
+def main(
+    input_dataset: str,
+    output_dataset: str,
+    image_column: str = "image",
+    task_mode: str = "plain",
+    hf_token: str = None,
+    split: str = "train",
+    max_samples: int = None,
+    private: bool = False,
+    shuffle: bool = False,
+    seed: int = 42,
+    output_column: str = "markdown",
+    config: str = None,
+    create_pr: bool = False,
+    compile: bool = True,
+    cudagraph: bool = True,
+    verbose: bool = False,
+):
+    check_cuda_availability()
+    start_time = datetime.now()
+
+    HF_TOKEN = hf_token or os.environ.get("HF_TOKEN")
+    if HF_TOKEN:
+        login(token=HF_TOKEN)
+
+    if task_mode not in TASK_MODES:
+        raise ValueError(
+            f"Invalid task_mode '{task_mode}'. Choose from: {list(TASK_MODES.keys())}"
+        )
+
+    logger.info(f"Task mode: {task_mode} - {TASK_MODES[task_mode]}")
+    logger.info(f"Output column: {output_column}")
+
+    # Load dataset
+    logger.info(f"Loading dataset: {input_dataset}")
+    dataset = load_dataset(input_dataset, split=split)
+
+    if image_column not in dataset.column_names:
+        raise ValueError(
+            f"Column '{image_column}' not found. Available: {dataset.column_names}"
+        )
+
+    if shuffle:
+        logger.info(f"Shuffling dataset with seed {seed}")
+        dataset = dataset.shuffle(seed=seed)
+
+    if max_samples:
+        dataset = dataset.select(range(min(max_samples, len(dataset))))
+        logger.info(f"Limited to {len(dataset)} samples")
+
+    # Load model using falcon-perception
+    logger.info(f"Loading model: {MODEL_ID} via falcon-perception engine")
+    from falcon_perception import load_and_prepare_model
+    from falcon_perception.data import ImageProcessor
+    from falcon_perception.paged_ocr_inference import OCRInferenceEngine
+
+    model, tokenizer, model_args = load_and_prepare_model(
+        hf_model_id=MODEL_ID,
+        device="cuda",
+        dtype="bfloat16",
+        compile=compile,
+    )
+
+    image_processor = ImageProcessor(patch_size=16, merge_size=1)
+    engine = OCRInferenceEngine(
+        model, tokenizer, image_processor, capture_cudagraph=cudagraph
+    )
+    logger.info(f"Engine loaded. compile={compile}, cudagraph={cudagraph}")
+
+    # Prepare all images
+    logger.info(f"Processing {len(dataset)} images...")
+    all_outputs = []
+
+    if task_mode == "layout":
+        # Process one at a time for layout (returns structured regions)
+        for i in tqdm(range(len(dataset)), desc="Falcon OCR (layout)"):
+            try:
+                pil_image = prepare_image(dataset[i][image_column])
+                results = engine.generate_with_layout(images=[pil_image], use_tqdm=False)
+                regions = results[0] if results else []
+                all_outputs.append(json.dumps(regions, ensure_ascii=False))
+            except Exception as e:
+                logger.error(f"Error processing image {i}: {e}")
+                all_outputs.append(f"[OCR ERROR: {str(e)[:200]}]")
+    else:
+        # Batch plain OCR for better throughput
+        batch_size = 8
+        for batch_start in tqdm(
+            range(0, len(dataset), batch_size), desc="Falcon OCR (plain)"
+        ):
+            batch_end = min(batch_start + batch_size, len(dataset))
+            batch_images = []
+            for i in range(batch_start, batch_end):
+                try:
+                    batch_images.append(prepare_image(dataset[i][image_column]))
+                except Exception as e:
+                    logger.error(f"Error preparing image {i}: {e}")
+                    batch_images.append(Image.new("RGB", (100, 100)))
+
+            try:
+                texts = engine.generate_plain(
+                    images=batch_images, use_tqdm=False
+                )
+                all_outputs.extend(texts)
+            except Exception as e:
+                logger.error(f"Error processing batch {batch_start}-{batch_end}: {e}")
+                all_outputs.extend(
+                    [f"[OCR ERROR: {str(e)[:200]}]"] * len(batch_images)
+                )
+
+    # Calculate processing time
+    processing_duration = datetime.now() - start_time
+    processing_time_str = f"{processing_duration.total_seconds() / 60:.1f} min"
+
+    # Add output column
+    logger.info(f"Adding '{output_column}' column to dataset")
+    dataset = dataset.add_column(output_column, all_outputs)
+
+    # Track inference info
+    inference_entry = {
+        "model_id": MODEL_ID,
+        "model_name": "Falcon-OCR",
+        "model_size": "0.3B",
+        "task_mode": task_mode,
+        "column_name": output_column,
+        "timestamp": datetime.now().isoformat(),
+        "backend": "falcon-perception",
+    }
+
+    if "inference_info" in dataset.column_names:
+        def update_inference_info(example):
+            try:
+                existing_info = (
+                    json.loads(example["inference_info"])
+                    if example["inference_info"]
+                    else []
+                )
+            except (json.JSONDecodeError, TypeError):
+                existing_info = []
+            existing_info.append(inference_entry)
+            return {"inference_info": json.dumps(existing_info)}
+
+        dataset = dataset.map(update_inference_info)
+    else:
+        inference_list = [json.dumps([inference_entry])] * len(dataset)
+        dataset = dataset.add_column("inference_info", inference_list)
+
+    # Push to hub
+    logger.info(f"Pushing to {output_dataset}")
+    max_retries = 3
+    for attempt in range(1, max_retries + 1):
+        try:
+            if attempt > 1:
+                logger.warning("Disabling XET (fallback to HTTP upload)")
+                os.environ["HF_HUB_DISABLE_XET"] = "1"
+            dataset.push_to_hub(
+                output_dataset,
+                private=private,
+                token=HF_TOKEN,
+                max_shard_size="500MB",
+                **({"config_name": config} if config else {}),
+                create_pr=create_pr,
+                commit_message=f"Add {MODEL_ID} OCR results ({len(dataset)} samples)"
+                + (f" [{config}]" if config else ""),
+            )
+            break
+        except Exception as e:
+            logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
+            if attempt < max_retries:
+                delay = 30 * (2 ** (attempt - 1))
+                logger.info(f"Retrying in {delay}s...")
+                time.sleep(delay)
+            else:
+                logger.error("All upload attempts failed. OCR results are lost.")
+                sys.exit(1)
+
+    # Create and push dataset card
+    logger.info("Creating dataset card")
+    card_content = create_dataset_card(
+        source_dataset=input_dataset,
+        task_mode=task_mode,
+        num_samples=len(dataset),
+        processing_time=processing_time_str,
+        image_column=image_column,
+        split=split,
+    )
+    card = DatasetCard(card_content)
+    card.push_to_hub(output_dataset, token=HF_TOKEN)
+
+    logger.info("Falcon OCR processing complete!")
+    logger.info(
+        f"Dataset available at: https://huggingface.co/datasets/{output_dataset}"
+    )
+    logger.info(f"Processing time: {processing_time_str}")
+    logger.info(
+        f"Speed: {len(dataset) / processing_duration.total_seconds():.2f} images/sec"
+    )
+
+    if verbose:
+        import importlib.metadata
+
+        logger.info("--- Resolved package versions ---")
+        for pkg in [
+            "falcon-perception", "transformers", "torch", "datasets", "pillow"
+        ]:
+            try:
+                logger.info(f"  {pkg}=={importlib.metadata.version(pkg)}")
+            except importlib.metadata.PackageNotFoundError:
+                logger.info(f"  {pkg}: not installed")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        print("=" * 70)
+        print("Falcon OCR - 0.3B Document OCR (falcon-perception engine)")
+        print("=" * 70)
+        print(f"\nModel: {MODEL_ID}")
+        print("License: Apache 2.0")
+        print("\nTask Modes:")
+        for mode, description in TASK_MODES.items():
+            print(f"  {mode:10} - {description}")
+        print("\nExamples:")
+        print("  uv run falcon-ocr.py input-dataset output-dataset")
+        print("  uv run falcon-ocr.py dense-docs output --task-mode layout")
+        print("\nFor full help: uv run falcon-ocr.py --help")
+        sys.exit(0)
+
+    parser = argparse.ArgumentParser(
+        description="Document OCR using Falcon OCR (0.3B, falcon-perception engine)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+
+    parser.add_argument("input_dataset", help="Input dataset ID from Hugging Face Hub")
+    parser.add_argument("output_dataset", help="Output dataset ID for Hugging Face Hub")
+    parser.add_argument(
+        "--image-column", default="image",
+        help="Column containing images (default: image)",
+    )
+    parser.add_argument(
+        "--task-mode", choices=list(TASK_MODES.keys()), default="plain",
+        help="Task type: plain (default), layout",
+    )
+    parser.add_argument("--hf-token", help="Hugging Face API token")
+    parser.add_argument(
+        "--split", default="train", help="Dataset split (default: train)",
+    )
+    parser.add_argument(
+        "--max-samples", type=int,
+        help="Maximum number of samples to process (for testing)",
+    )
+    parser.add_argument(
+        "--private", action="store_true", help="Make output dataset private",
+    )
+    parser.add_argument(
+        "--shuffle", action="store_true", help="Shuffle dataset before processing",
+    )
+    parser.add_argument(
+        "--seed", type=int, default=42, help="Random seed for shuffling (default: 42)",
+    )
+    parser.add_argument(
+        "--output-column", default="markdown",
+        help="Column name for output text (default: markdown)",
+    )
+    parser.add_argument(
+        "--config",
+        help="Config/subset name for Hub (for benchmarking multiple models)",
+    )
+    parser.add_argument(
+        "--create-pr", action="store_true",
+        help="Create a pull request instead of pushing directly",
+    )
+    parser.add_argument(
+        "--no-compile", action="store_true",
+        help="Disable torch.compile",
+    )
+    parser.add_argument(
+        "--no-cudagraph", action="store_true",
+        help="Disable CUDA graph capture",
+    )
+    parser.add_argument(
+        "--verbose", action="store_true", help="Log resolved package versions",
+    )
+
+    args = parser.parse_args()
+
+    main(
+        input_dataset=args.input_dataset,
+        output_dataset=args.output_dataset,
+        image_column=args.image_column,
+        task_mode=args.task_mode,
+        hf_token=args.hf_token,
+        split=args.split,
+        max_samples=args.max_samples,
+        private=args.private,
+        shuffle=args.shuffle,
+        seed=args.seed,
+        output_column=args.output_column,
+        config=args.config,
+        create_pr=args.create_pr,
+        compile=not args.no_compile,
+        cudagraph=not args.no_cudagraph,
+        verbose=args.verbose,
+    )