GLiNER Documentation

GLiNER (Generalist and Lightweight Model for Named Entity Recognition) is a framework for training and deploying Named Entity Recognition (NER) models capable of identifying any arbitrary entity type.

It serves as a middle ground between:

1. Traditional NER models: Which are limited to a fixed set of predefined entity types.
2. Large Language Models (LLMs): Which offer high flexibility but require significant computational resources.

Supported architectures include bidirectional transformer encoders, scalable bi-encoders, relation extraction models, and a causal StreamingSpan model for incremental text processing.

A complete GLiNER architecture is composed of five main components that work together to handle everything from configuration to user-facing inference. To extend GLiNER, you may need to implement one or more of these components by inheriting from their respective base classes.

| Component | Purpose | Base Class |
|-----------|---------|------------|
| **Configuration** | Store model hyperparameters and settings | `BaseGLiNERConfig` |
| **Model** | Neural network architecture (forward pass, loss) | `BaseModel` |
| **Processor** | Data preprocessing and tokenization | `BaseProcessor` |
| **Decoder** | Convert model outputs to entity predictions | `BaseDecoder` |
| **High-Level Wrapper** | User-facing API and orchestration | `BaseGLiNER` |

The Bi-encoder architecture (including BiEncoderSpan and BiEncoderToken variants) decouples the encoding of entity labels from the input sequence. This addresses performance bottlenecks in the original GLiNER architecture, such as positional encoding constraints and performance degradation when using more than 30 entity labels.

Variants:

• BiEncoderSpan: Uses span-level predictions; best for standard NER with discrete entity mentions.
• BiEncoderToken: Uses token-level predictions; better for long-form entities and efficient with pre-computed label embeddings.

Advantages:

• Supports large numbers of entities (50-200+) without performance loss.
• Faster inference via pre-computed and cached label embeddings.
• Improved zero-shot performance and robustness.

GLiNER supports several architecture variants, each requiring a specific configuration class. Choose the architecture based on your use case:

BiEncoder models are optimized for handling many entity types (50-200+). To maximize performance in production, you can pre-compute label embeddings using encode_labels and then use predict_with_embeds for faster inference.

from gliner import GLiNER

model = GLiNER.from_pretrained("knowledgator/gliner-bi-small-v1.0")
labels = ["person", "organization", "location", "date", "product", "event"] # ... can be 100+
text = "Python is a programming language created by Guido van Rossum."

# 1. Pre-compute label embeddings
label_embeddings = model.encode_labels(labels, batch_size=16)

# 2. Use cached embeddings for faster inference
entities = model.predict_with_embeds(
    text, 
    label_embeddings, 
    labels,
    threshold=0.5
)

To improve training control and handle hard negatives, you can add optional keys to your NER training dictionaries:

• ner_labels: A list of entity types present in the example. Useful for fixed label set use cases.
• ner_negatives: A list of entity types to use as negative examples (e.g., including "company" as a negative when training for "organization" to help the model distinguish similar types).

train_data = [
    {
        "tokenized_text": ["Apple", "Inc.", "hired", "Tim", "Cook", "in", "1998"],
        "ner": [
            [0, 1, "organization"],
            [3, 4, "person"],
            [6, 6, "date"]
        ],
        "ner_labels": ["organization", "person", "date", "location"],
        "ner_negatives": ["product", "event", "money"]
    }
]

You can containerize the GLiNER server using the provided Containerfile.

Build the image:

docker build -t gliner-serve -f gliner/serve/Containerfile .

Run the container:

docker run --gpus all -p 8000:8000 gliner-serve

Run with custom configuration via environment variables:

docker run --gpus all -p 8000:8000 \
  -e GLINER_MODEL=urchade/gliner_medium-v2.1 \
  -e GLINER_ENABLE_FLASHDEBERTA=true \
  gliner-serve

FlashDeBERTa can provide up to a 3× speed boost for GLiNER models using DeBERTa encoders.

Prerequisites:

• Install flashdeberta: pip install flashdeberta -U
• Ensure transformers>=4.51.3 is installed.

Activation: You must set the USE_FLASHDEBERTA environment variable to 1 before loading the model. You can do this via the shell or directly in Python.

# Via shell
export USE_FLASHDEBERTA=1

import os
os.environ["USE_FLASHDEBERTA"] = "1"

from gliner import GLiNER
model = GLiNER.from_pretrained("urchade/gliner_mediumv2.1")