💬 NLP

The Million-Label NER: Breaking Scale Barriers with GLiNER bi-encoder

This paper introduces GLiNER-bi-Encoder, a novel bi-encoder architecture that overcomes the quadratic complexity of traditional NER models to enable efficient, state-of-the-art zero-shot recognition of millions of entity types, alongside the GLiNKER framework for high-performance entity linking.

Original authors: Ihor Stepanov, Mykhailo Shtopko, Dmytro Vodianytskyi, Oleksandr Lukashov

Published 2026-02-24

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Ihor Stepanov, Mykhailo Shtopko, Dmytro Vodianytskyi, Oleksandr Lukashov

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a librarian trying to organize a massive, chaotic library. Your job is to find specific types of books (like "Science Fiction," "Cooking," or "History") hidden inside thousands of messy, handwritten notes left by visitors.

For a long time, the best way to do this was to have a Super-Intelligent Librarian (the original GLiNER model) who would read every single note and every single book category definition at the exact same time.

The Problem: The "All-at-Once" Bottleneck

Imagine the Super-Intelligent Librarian has to compare every note against every book category simultaneously.

If you have 10 categories, it's easy.
If you have 100 categories, it gets harder.
But if you have 1 million categories (like every concept in the entire universe of knowledge), the Librarian has to do a million comparisons for every single note.

This is like trying to find a specific needle in a haystack by holding every single needle in your hand and comparing them one by one. As the number of needles (labels) grows, the work explodes. It becomes too slow and too expensive to run in real-time. This is the "quadratic complexity" problem the paper solves.

The Solution: The "Two-Team" System (GLiNER-bi-Encoder)

The authors of this paper, Knowledgator Engineering, realized they didn't need one person doing everything. Instead, they split the job into two specialized teams working in parallel:

The Text Team (Context Encoder): This team reads the messy notes and highlights the interesting parts (the "spans" of text). They don't worry about what the books are called yet; they just find the potential candidates.
The Label Team (Label Encoder): This team takes the definitions of the book categories (e.g., "A person who writes code") and turns them into digital ID cards (embeddings) before the work even starts.

The Magic Trick:
Because the "Label Team" does its work ahead of time, they can create a massive, pre-organized index of all 1 million categories. When the "Text Team" finds a potential match in a note, they just do a quick, lightning-fast search against the pre-made index.

It's like the difference between:

Old Way: Reading a dictionary from A to Z every time you find a new word to see if it's a noun. (Slow, gets slower as the dictionary grows).
New Way: Having a pre-sorted index card system where you just look up the word and instantly see if it's a noun. (Fast, stays fast even if you add a million new words).

Why This Matters (The "Million-Label" Breakthrough)

The paper shows that this new system can handle millions of entity types without slowing down.

Speed: At 1,024 categories, the new system is 130 times faster than the old one.
Accuracy: It's just as smart as the old system, achieving top-tier scores (61.5% F1) on difficult tests.
Flexibility: You can swap out the "Text Team" for a faster one or the "Label Team" for a smarter one without breaking the whole system.

Real-World Analogy: The "Super-Connector"

Think of this technology as a universal translator for knowledge.

Old System: Like a translator who has to memorize every language and every sentence structure before speaking. If you add a new language, they have to relearn everything.
New System (GLiNER-bi-Encoder): Like a translator who has a massive, pre-translated dictionary of every language in the world. When you speak, they just look up your words in the dictionary. If you add a new language tomorrow, you just update the dictionary, and the translator keeps working instantly.

The "GLiNKER" Bonus

The paper also introduces GLiNKER, which takes this speed and uses it for Entity Linking.

NER (The first part): Finding the word "Apple" in a sentence.
Entity Linking (The second part): Knowing if "Apple" means the fruit or the tech company.
GLiNKER: Because the system is so fast at checking millions of possibilities, it can instantly decide which "Apple" is being talked about by searching through a massive database (like Wikidata) in real-time.

In a Nutshell

The paper introduces a smarter, faster way to find and categorize things in text. By splitting the work into "reading the text" and "preparing the categories," they broke the speed barrier that stopped computers from handling massive lists of topics. This means we can now build AI systems that understand complex, specialized fields (like medicine or law) with millions of specific terms, all while running fast enough for real-time use.

1. Problem Statement

Named Entity Recognition (NER) is a fundamental task in Information Extraction (IE), but existing state-of-the-art approaches face significant scalability bottlenecks when handling large numbers of entity types (labels).

The Limitation of Joint Encoding: The original GLiNER framework uses a uni-encoder (joint-encoding) architecture where text and entity type descriptions are processed together in a single transformer. This results in quadratic computational complexity $O((n + m)^2)$ , where $n$ is the text length and $m$ is the number of entity labels.
The Consequence: As the number of entity labels increases (e.g., from dozens to thousands or millions, as required in biomedical ontologies like UMLS or enterprise knowledge bases), the inference time becomes prohibitive, and memory usage explodes. This prevents the deployment of zero-shot NER in scenarios requiring massive taxonomies.
The Gap: While generative models (LLMs) offer flexibility, they suffer from high latency and output consistency issues. Discriminative models need a new architecture to decouple label processing from text processing to achieve industrial-scale efficiency.

2. Methodology: GLiNER Bi-Encoder

The authors propose GLiNER-bi-Encoder, a novel architecture that decouples the encoding of text and entity labels into two independent components.

Core Architecture

Dual Encoders: Instead of a single transformer, the system uses two specialized encoders:
1. Text Encoder: Processes the input text sequence to generate span representations.
2. Label Encoder: Independently encodes entity type descriptions (e.g., "chemical compound," "person").
Decoupling Mechanism:
- Text Encoding: Complexity is $O(n^2)$ , independent of the number of labels.
- Label Encoding: Labels are encoded offline and pre-computed. These embeddings are cached in vector databases.
- Scoring: During inference, the model computes compatibility between text spans and pre-computed label embeddings via dot-product scoring (or optional cross-attention fusion).
Scalability: With pre-computed labels, the inference complexity becomes effectively $O(n^2)$ regardless of whether the system recognizes 10 or 1,000,000 entity types. The label retrieval is reduced to an efficient nearest-neighbor search.

Model Variants & Training

The authors trained four model variants based on the ModernBERT architecture, paired with specialized sentence transformers for label encoding:

Edge (32M params): Paired with all-MiniLM-L6-v2.
Small (68M params): Paired with all-MiniLM-L12-v2.
Base (150M params): Paired with bge-small-en-v1.5.
Large (400M params): Paired with bge-base-en-v1.5.

Training Strategy:

Pre-training: 8M–10M samples using Focal Loss to handle class imbalance.
Post-training: 40k high-quality samples with extended context (up to 2048 tokens) to refine generalization.
Negative Sampling: Stochastic negative masking to manage the quadratic number of candidate spans.

Optional Cross-Attention

To address potential loss of cross-modal interaction, an optional CrossFuser layer can be added to exchange information between text and label representations via bidirectional attention, offering a tunable trade-off between accuracy and efficiency.

3. Key Contributions

GLiNER-bi-Encoder Architecture: A scalable bi-encoder design that breaks the quadratic complexity barrier, enabling simultaneous recognition of thousands to millions of entity types with minimal overhead.
GLiNKER Framework: A modular, DAG-based framework extending the bi-encoder for Entity Linking. It integrates mention extraction, candidate generation from massive knowledge bases (e.g., Wikidata), and disambiguation, leveraging pre-computed embeddings for efficient retrieval.
State-of-the-Art Zero-Shot Performance: The model achieves competitive or superior performance compared to uni-encoder GLiNER variants across diverse domains without fine-tuning.
Massive Throughput Improvement: Demonstrates a 130× speedup in inference throughput at 1,024 labels compared to uni-encoder predecessors when using pre-computed label embeddings.

4. Experimental Results

The models were evaluated on 26 zero-shot NER benchmarks (including CrossNER, CoNLL 2003, BioBERT datasets, and social media corpora) on a single NVIDIA H100 GPU.

Accuracy:
- The GLiNER-bi-large-v2.0 achieved 61.5% Micro-F1 on the CrossNER benchmark, outperforming the best uni-encoder GLiNER (60.9%).
- Strong performance in biomedical domains: GENIA_NER (60.1%) and bc5cdr (71.7%).
- The Base variant (194M params) achieved 98% of the Large model's performance while running 2.6× faster.
Scalability & Speed:
- Uni-Encoder Degradation: As label counts increased to 1,024, uni-encoder models suffered a 98.7% drop in throughput (e.g., from 10.7 to 0.14 examples/s).
- Bi-Encoder Stability: The bi-encoder with pre-computed labels maintained near-constant speed, showing only a 5.2% drop (19.3 to 18.3 examples/s).
- Throughput Gain: At 1,024 labels, the bi-encoder is 130× faster than the comparable uni-encoder. At 100 labels, it is 5.3× faster.
Generalization: The model showed strong generalization to specialized domains (biomedical, legal) without fine-tuning, though performance on highly contextual datasets (e.g., HarveyNER) remained challenging.

5. Significance and Impact

Enabling Million-Label NER: This work makes it computationally feasible to deploy NER systems against massive ontologies (like UMLS with 4M+ concepts) in real-time, a task previously impossible with joint-encoding architectures.
Democratizing NLP Efficiency: By drastically reducing inference costs and latency, the architecture allows high-accuracy NER to be deployed in resource-constrained environments and reduces the environmental footprint of large-scale text processing.
Unified Entity Extraction & Linking: The introduction of GLiNKER bridges the gap between NER and Entity Linking, providing a unified, scalable pipeline for knowledge-intensive applications.
Architectural Paradigm Shift: The paper advocates for a shift from monolithic joint-encoding models to modular, decomposable systems where components (text vs. labels) can be optimized, cached, and retrieved independently, a principle applicable to broader structured prediction tasks.

In conclusion, GLiNER-bi-Encoder successfully resolves the trade-off between zero-shot flexibility and industrial-scale efficiency, establishing a new standard for scalable information extraction.