GLiNER

GLiNER2 models are specialized for named entity recognition and information extraction.

Usage

import gliner2
from sieves import tasks

# Initialize a GLiNER model
model = gliner2.GLiNER2.from_pretrained("fastino/gliner2-base-v1")

# Pass it to a task (Note: GLiNER is specialized for extraction/classification)
task = tasks.NER(
    entities=["PERSON", "LOC"],
    model=model
)

---

Bases: ModelWrapper[PromptSignature, Result, Model, InferenceMode]

ModelWrapper adapter for GLiNER2.

Source code in sieves/model_wrappers/gliner_.py

class GliNER(ModelWrapper[PromptSignature, Result, Model, InferenceMode]):
    """ModelWrapper adapter for GLiNER2."""

    @override
    @property
    def inference_modes(self) -> type[InferenceMode]:
        return InferenceMode

    @override
    @property
    def supports_few_shotting(self) -> bool:
        return False

    @override
    def build_executable(
        self,
        inference_mode: InferenceMode,
        prompt_template: str | None,
        prompt_signature: type[PromptSignature] | PromptSignature,
        fewshot_examples: Sequence[pydantic.BaseModel] = (),
    ) -> Executable[Result]:
        cls_name = self.__class__.__name__
        if len(list(fewshot_examples)):
            warnings.warn(f"Few-shot examples are not supported by model type {cls_name}.")

        # Overwrite prompt default template, if template specified. Note that this is a static prompt and GliNER doesn't
        # do few-shotting, so we don't inject anything into the template.
        if prompt_template:
            self._model.prompt = jinja2.Template(prompt_template).render()

        def execute(values: Sequence[dict[str, Any]]) -> Sequence[tuple[Result, Any, TokenUsage]]:
            """Execute prompts with model wrapper for given values.

            :param values: Values to inject into prompts.
            :return: Sequence of tuples containing results, raw outputs, and token usage.
            """
            results = self._model.batch_extract(
                texts=[val["text"] for val in values],
                schemas=prompt_signature,
                **(
                    {"batch_size": len(values)}
                    | self._inference_kwargs
                    | {"include_confidence": True, "include_spans": True}
                ),
            )

            # Estimate token usage if tokenizer is available.
            tokenizer = self._get_tokenizer()

            final_results: list[tuple[Result, Any, TokenUsage]] = []
            # Estimate token counts.
            for val, res in zip(values, results):
                usage = TokenUsage(
                    input_tokens=self._count_tokens(val["text"], tokenizer),
                    output_tokens=self._count_tokens(str(res), tokenizer),
                )

                final_results.append((res, res, usage))
            return final_results

        return execute

    @override
    def _get_tokenizer(self) -> Any | None:
        # GLiNER2 models usually have a tokenizer accessible through the processor.
        tokenizer = getattr(self._model, "tokenizer", None)
        if not tokenizer and hasattr(self._model, "processor"):
            tokenizer = getattr(self._model.processor, "tokenizer", None)

        return tokenizer

model property

Return model instance.

Returns:

Type	Description
ModelWrapperModel	Model instance.

model_settings property

Return model settings.

Returns:

Type	Description
ModelSettings	Model settings.

__init__(model, model_settings)

Initialize model wrapper with model and model settings.

Parameters:

Name	Type	Description	Default
model	ModelWrapperModel	Instantiated model instance.	required
model_settings	ModelSettings	Model settings.	required

Source code in sieves/model_wrappers/core.py

def __init__(self, model: ModelWrapperModel, model_settings: ModelSettings):
    """Initialize model wrapper with model and model settings.

    :param model: Instantiated model instance.
    :param model_settings: Model settings.
    """
    self._model = model
    self._model_settings = model_settings
    self._inference_kwargs = model_settings.inference_kwargs or {}
    self._init_kwargs = model_settings.init_kwargs or {}
    self._strict = model_settings.strict

convert_fewshot_examples(fewshot_examples) staticmethod

Convert few‑shot examples to dicts.

Parameters:

Name	Type	Description	Default
fewshot_examples	Sequence[BaseModel]	Fewshot examples to convert.	required

Returns:

Type	Description
list[dict[str, Any]]	Fewshot examples as dicts.

Source code in sieves/model_wrappers/core.py

@staticmethod
def convert_fewshot_examples(fewshot_examples: Sequence[pydantic.BaseModel]) -> list[dict[str, Any]]:
    """Convert few‑shot examples to dicts.

    :param fewshot_examples: Fewshot examples to convert.
    :return: Fewshot examples as dicts.
    """
    return [fs_example.model_dump(serialize_as_any=True) for fs_example in fewshot_examples]