# CommonForms: A Large, Diverse Dataset for Form Field Detection > CommonForms is a 480k-page dataset of fillable PDF forms mined from Common Crawl, paired with FFDNet, a family of YOLO11-based form field detectors that qualitatively outperform Adobe Acrobat. - Authors: Bevaya AI Team - Published: 2026-03-13 - Paper: Preprint (arXiv) - Dataset: CommonForms - Model: FFDNet-L - Model: FFDNet-S - Code: GitHub Repository - Demo: Hosted Demo (may be intermittently unavailable) - Source: Bevaya Labs, --- ## TL;DR CommonForms is a **480k-page dataset** of fillable PDF forms mined from Common Crawl, covering 10+ languages and 14 domains. The authors also train and release **FFDNet-S** (9M params per paper; 6M per released HuggingFace card) and **FFDNet-L** (25M params), high-resolution YOLO11 object detectors for form field detection that achieve 81.0 mAP$\_{50-95}$ and qualitatively outperform Adobe Acrobat, including on choice buttons (checkboxes/radio buttons) that Acrobat does not detect at all. Note: due to a processing error acknowledged in the paper, the released models were trained on ~350K pages rather than the full ~480K. --- ## What kind of paper is this? **Dominant:** $\Psi\_{\text{Resource}}$ The headline contribution is the dataset: a large-scale, diverse collection of form images with form field annotations bootstrapped from existing fillable PDFs. The paper devotes substantial attention to the curation pipeline, filtering strategy, language/domain analysis, and annotation consistency discussion. **Secondary:** $\Psi\_{\text{Method}}$ The FFDNet family of detectors is a meaningful secondary contribution. While they are straightforward YOLO11 models (not architecturally novel), the authors release trained weights and demonstrate that high-resolution inputs and aggressive data filtering are important practical design choices for this task. ## What is the motivation? Despite decades of digitalization, many real-world transactions still rely on paper forms distributed as flat (non-fillable) PDFs. Making these forms digitally fillable requires two steps: (1) **form field detection** (locating where fields should go and what type they are) and (2) **form enrichment** (grouping fields with labels for semantics and accessibility). Prior work (Form2Seq, FormAlly) focused on the second step, assuming fields are already detected. There was no large-scale, open dataset for the detection step itself. Existing form understanding datasets like FUNSD (199 forms) and NAF (77 forms) target key information extraction from *filled* forms, not detection of empty fields. Commercial tools like Adobe Acrobat offer form preparation, but are proprietary, do not detect choice buttons, and (as the authors demonstrate) suffer from low recall and precision. ## What is the novelty? The core insight is that the web already contains a large supply of well-prepared fillable PDFs. By mining Common Crawl, the authors bootstrap training data without manual annotation: 1. **Dataset construction via aggressive filtering.** Starting from 7.9M PDFs in a Common Crawl snapshot, the pipeline filters to documents containing AcroForm or XFA form objects (~762K), then removes documents with no fields or only buttons (~59K), and finally cleans individual field annotations (removing out-of-bounds, too-small, and near-duplicate fields). The result is ~59K documents with 480K+ pages (the paper is internally inconsistent, citing both ~55K in the abstract and ~59K in the pipeline description; the detailed filtering pipeline supports ~59K). 2. **Form field detection as object detection.** The task is cast as predicting bounding boxes and types for three classes: **Text Input**, **Choice Button** (checkboxes and radio buttons), and **Signature**. This is notable because commercial tools like Adobe Acrobat and Apple Preview do not detect choice buttons at all. 3. **High-resolution matters.** An ablation across input resolutions (640px to 1536px) shows a ~20 mAP point spread, with choice buttons and signatures benefiting most from higher resolution. The authors settle on 1216px as a practical tradeoff. 4. **Filtering improves data efficiency.** Training on 10K pages from the filtered set yields ~4 mAP points higher than training on 10K pages from the unfiltered set (57.9 vs. 53.6), validating the cleaning pipeline. ## What experiments were performed? All results are reported as mAP$\_{50-95}$ on the CommonForms test set (25K pages, split by document to prevent leakage). ### Main results (Table 3) | Model | Text AP | Choice AP | Sig. AP | All AP | | :--- | :--- | :--- | :--- | :--- | | FFDNet-S (1216px, 9M) | 61.5 | 71.3 | 84.2 | 72.3 | | FFDNet-L (1216px, 25M) | 71.4 | 78.1 | 93.5 | 81.0 | ### Resolution ablation (Table 4) A 6M parameter model trained on 10K pages at varying resolutions: | Resolution | All AP | | :--- | :--- | | 640px | 42.7 | | 960px | 52.8 | | 1216px | 57.9 | | 1536px | 62.1 | ### Qualitative comparison with Adobe Acrobat (Table 2) The authors show side-by-side examples on English and Arabic forms. Acrobat does not predict choice buttons, and exhibits lower recall (missing many fields) and lower precision (detecting table lines and separators as text fields). Both FFDNet-S and FFDNet-L detect text, choice, and signature fields with higher coverage and fewer false positives. ### Cross-language and cross-domain robustness (Table 5) FFDNet-L performs consistently across 9 of the 10 most common languages (AP 73.8 to 89.3), with degraded performance on Russian (69.2). FFDNet-S shows higher variance across languages and domains. Across 14 domains, performance ranges from 75.5 ("Other") to 88.9 ("Real Estate") for FFDNet-L. ### Data efficiency (Section 5.4) Training on filtered data yields 57.9 mAP vs. 53.6 from unfiltered data (same 10K page budget), a ~4 point improvement from the cleaning pipeline. ## What are the outcomes/conclusions? **Key findings:** - CommonForms is (to the authors' knowledge) the first large-scale open dataset for form field detection, with 480K pages from ~59K documents spanning 10+ languages and 14 domains. - FFDNet-L achieves 81.0 mAP$\_{50-95}$, with particularly strong signature detection (93.5 AP). - High-resolution input is critical: a 20-point mAP spread across resolutions from 640px to 1536px. - The aggressive filtering pipeline improves data efficiency by ~4 mAP points. - FFDNet qualitatively outperforms Adobe Acrobat, and uniquely detects choice buttons. - Each model costs less than $500 to train. **Limitations:** - **Annotation noise.** The dataset inherits inconsistencies from web-scraped forms: "For Official Use Only" sections are inconsistently fillable, signatures are sometimes implemented as text fields, and scanned pages within otherwise digital PDFs lack annotations. The authors catalog these issues but do not attempt to fix them. - **No semantic understanding.** The models detect field locations and types but do not group fields with labels or understand form semantics (the "form enrichment" step). - **Qualitative-only comparison with baselines.** The Acrobat comparison is qualitative (visual examples), not quantitative. There are no numeric comparisons against other open-source detectors or layout models. - **Single architecture family.** Only YOLO11 variants are evaluated. No comparison with DETR, Faster R-CNN, or multimodal alternatives. - **Russian underperformance.** FFDNet-S drops to 33.2 AP on Russian forms; the authors note this but do not investigate causes beyond parameter count. - **Training data processing error.** A footnote in the paper acknowledges that both released models were trained on only ~350K pages rather than the full ~480K, due to a processing error. The authors state they are working on retraining. - **Single Common Crawl snapshot.** The entire dataset comes from one July/August 2021 scrape, limiting temporal and source diversity. - **Unverified non-English domain labels.** Domain classification used LDA + GPT-5 labeling, but only English-language topics were manually verified. Non-English domain labels may contain errors. **Future work** identified by the authors: tackling the full form preparation problem (semantics), improving performance on scans and foreign-language documents via augmentation or resampling, and cleaning up annotation inconsistencies. --- ## Reproducibility ### Models - **FFDNet-S**: 9M parameters per the paper, but the released HuggingFace card reports 6M parameters. The discrepancy may reflect retraining (see below). YOLO11-based, initialized from scratch (not pretrained). - **FFDNet-L**: 25M parameters, YOLO11-based, initialized from scratch - Both accept 1216px input resolution - **Training data caveat**: A footnote in the paper states that both released models were trained on only ~350K pages (not the full ~480K) due to a processing error. The authors indicate they are working on retraining. - Weights released on HuggingFace. The HuggingFace model cards do not specify a license; Apache-2.0 is inferred from a GitHub release note mentioning "Apache-licensed FFDetr" and from the dataset's Apache-2.0 license. Verify before commercial use. ### Algorithms - **Training**: 300 epochs, initial learning rate 0.001 - **Architecture**: YOLO11 object detector (via Ultralytics) - **Classes**: Text Input, Choice Button, Signature - The paper does not report batch size, optimizer, learning rate scheduler, data augmentation, or loss function details. Ultralytics YOLO11 defaults are presumably used (SGD with momentum 0.937, cosine LR annealing, mosaic/mixup augmentation, combined box regression + classification + DFL loss). - Hyperparameters and resolution chosen by training on subsets and observing generalization ### Data - **Source**: Common Crawl July/August 2021 scrape (PDF Association collection) - **Size**: 7.9M PDFs filtered to ~59K documents, 480K+ pages - **Splits**: Train/val/test split by document (not page); 8K validation pages, 25K test pages, remainder for training - **Annotations**: Bootstrapped from existing fillable PDF form fields (AcroForm and XFA standards); no manual annotation - **Language ID**: FastText per-page classification; 63.6% English, ~36% other languages - **Domain classification**: LDA topic modeling (300 topics via MALLET), labels assigned by GPT-5. Only English-language topics were manually verified; non-English labels are unverified. - Released on HuggingFace under Apache-2.0; includes per-page text, language, and domain labels ### Evaluation - **Metric**: mAP$\_{50-95}$ (standard COCO-style average precision) - **Baselines**: Only Adobe Acrobat (qualitative comparison). No quantitative comparison with other open-source detectors - **No error bars or multi-run statistics reported** - **No cross-validation**: single train/val/test split ### Hardware - **Training**: 4$\times$V100 GPUs (compute grant from LambdaLabs) - **Training time**: FFDNet-L ~5 days, FFDNet-S ~2 days - **Training cost**: < $500 per model - **Inference**: FFDNet-L ~16ms/page, FFDNet-S ~5ms/page on a single 3090 Ti - VRAM requirements and CPU-only feasibility are not reported --- ## BibTeX ```bibtex @article{barrow2025commonforms, title={CommonForms: A Large, Diverse Dataset for Form Field Detection}, author={Barrow, Joe}, journal={arXiv preprint arXiv:2509.16506}, year={2025} } ```