GLiNER2

By default, .classification() performs single-label classification (returning a single string). To allow multiple labels to be assigned to a single text, set multi_label=True.

You can also control which labels are returned by setting a cls_threshold. Only labels with a confidence score above this threshold will be included in the output list.

schema = (extractor.create_schema()
    # Single-label classification
    .classification("primary_topic", ["tech", "business", "health", "sports", "politics"])
    
    # Multi-label classification with a threshold
    .classification("emotions", 
        ["happy", "sad", "angry", "surprised", "fearful", "disgusted"],
        multi_label=True,
        cls_threshold=0.4
    )
)

text = "URGENT: I'm thrilled to announce our new product!"
results = extractor.extract(text, schema)
# 'emotions' will return a list of labels meeting the threshold

To handle multi-domain workloads efficiently, you can implement routing logic or batch processing by domain.

Routing: Map document types to specific adapter paths and call load_adapter only when the domain changes.

Batch Processing: Group documents by their domain and process them in batches. This minimizes the overhead of switching adapters by loading a single adapter once for all documents in that domain.

# Example of routing logic
def extract_with_routing(model, text, doc_type, adapters):
    adapter_path = adapters.get(doc_type)
    if adapter_path:
        model.load_adapter(adapter_path)
    else:
        model.unload_adapter()
    
    entity_types = {
        "legal": ["company", "person", "law"],
        "medical": ["disease", "drug", "symptom"],
        "support": ["order_id", "customer", "issue"]
    }
    return model.extract_entities(text, entity_types.get(doc_type, ["entity"]))

# Example of batch processing by domain
def process_by_domain(model, documents, adapters):
    results = {}
    for domain, docs in documents.items():
        model.load_adapter(adapters[domain])
        results[domain] = [
            model.extract_entities(doc, get_entity_types(domain))
            for doc in docs
        ]
    return results

GLiNER2 allows you to build complex, multi-task schemas using a fluent API. By combining different extraction methods, you can perform multiple information extraction tasks (like entity extraction, text classification, and structured data extraction) in a single model pass. This improves efficiency and maintains context across tasks.

Supported schema components include:

• .entities(labels): Extracts specific entity types. Labels can be a list of strings or a dictionary mapping labels to descriptions.
• .classification(label, choices): Classifies the text into one of the provided categories.
• .structure(name): Defines a structured object with specific fields using .field(name, ...).
• .relations(label): Extracts relationships between entities.

from gliner2 import GLiNER2

extractor = GLiNER2.from_pretrained("your-model-name")

schema = (extractor.create_schema()
    .entities(["person", "product", "company"])
    .classification("sentiment", ["positive", "negative", "neutral"])
    .classification("category", ["review", "news", "opinion"])
)

text = "Tim Cook announced that Apple's new iPhone is exceeding sales expectations."
results = extractor.extract(text, schema)

Fields in the extract_json schema use a :: separator to define types, choices, and descriptions.

Specification Formats:

• "field_name::type::description"
• "field_name::[choice1|choice2|choice3]::type::description" (for classification within a structure)
• "field_name::description" (defaults to list type)
• "field_name" (simple field, defaults to list)

Supported Types & Behaviors:

• str: Extracts the value as a string.
• list: Extracts multiple values into a list (default behavior if type is omitted).
• Choices: Using [choice1|choice2] allows you to perform classification within the structured extraction, forcing the model to pick from the provided options.

# Example of choice fields and descriptions
results = extractor.extract_json(
    text,
    {
        "reservation": [
            "restaurant::str::Restaurant name",
            "date::str",
            "time::str",
            "party_size::[1|2|3|4|5|6+]::str::Number of guests",
            "seating::[indoor|outdoor|bar]::str::Seating preference",
            "dietary::[vegetarian|vegan|gluten-free|none]::list::Dietary restrictions"
        ]
    }
)

Use create_schema() to build a comprehensive analysis pipeline that performs entity extraction, classification, relation extraction, and structured data extraction in a single pass.

Supported schema methods:

• .entities(dict): Defines entity types and descriptions.
• .classification(key, labels, multi_label=False, cls_threshold=None): Defines classification tasks.
• .relations(dict): Defines relationship types and descriptions.
• .structure(key): Starts a structured data block, followed by .field(name, dtype, choices=None) calls.

Once the schema is built, pass it to extractor.extract(text, schema).

# Use create_schema() for multi-task scenarios
schema = (extractor.create_schema()
    # Extract key entities
    .entities({
        "person": "Names of people, executives, or individuals",
        "company": "Organization, corporation, or business names", 
        "product": "Products, services, or offerings mentioned"
    })
    
    # Classify the content
    .classification("sentiment", ["positive", "negative", "neutral"])
    .classification("category", ["technology", "business", "finance", "healthcare"])
    
    # Extract relationships
    .relations(["works_for", "founded", "located_in"])
    
    # Extract structured product details
    .structure("product_info")
        .field("name", dtype="str")
        .field("price", dtype="str")
        .field("features", dtype="list")
        .field("availability", dtype="str", choices=["in_stock", "pre_order", "sold_out"])
)

# Comprehensive extraction in one pass
text = "Apple CEO Tim Cook unveiled the revolutionary iPhone 15 Pro for $999. The device features an A17 Pro chip and titanium design. Tim Cook works for Apple, which is located in Cupertino."

results = extractor.extract(text, schema)