Struct Relation 

pub struct Relation {
    pub head: Entity,
    pub tail: Entity,
    pub relation_type: String,
    pub trigger_span: Option<(usize, usize)>,
    pub confidence: f64,
}

A relation between two entities, forming a knowledge graph triple.

In the GLiNER bi-encoder paradigm, relations are detected just like entities: the relation trigger text (“CEO of”, “located in”) is matched against relation type labels in the same latent space.

Structure

Triple: (Head, Relation, Tail)

"Marie Curie worked at the Sorbonne"
 ^^^^^^^^^^^ ~~~~~~~~~ ^^^^^^^^
 Head        Rel       Tail
 (Person)  (Employment)  (Organization)

TPLinker/Joint Extraction

For joint extraction, relations are extracted in a single pass with entities. The trigger_span captures the text that indicates the relation.

Fields

head: Entity

The source entity (head of the triple)

tail: Entity

The target entity (tail of the triple)

relation_type: String

Relation type label (e.g., “EMPLOYMENT”, “LOCATED_IN”, “FOUNDED_BY”)

trigger_span: Option<(usize, usize)>

Optional trigger span: the text that indicates this relation For “CEO of”, this would be the span covering “CEO of”

confidence: f64

Confidence score for this relation (0.0-1.0)

Implementations

impl Relation

pub fn new( head: Entity, tail: Entity, relation_type: impl Into<String>, confidence: f64, ) -> Relation

Create a new relation between two entities.

pub fn with_trigger( head: Entity, tail: Entity, relation_type: impl Into<String>, trigger_start: usize, trigger_end: usize, confidence: f64, ) -> Relation

Create a relation with an explicit trigger span.

pub fn as_triple(&self) -> String

Convert to a triple string representation (for debugging/display).

pub fn span_distance(&self) -> usize

Check if the head and tail entities are adjacent (within n tokens). Useful for filtering spurious long-distance relations.

Trait Implementations

impl Clone for Relation

fn clone(&self) -> Relation

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Relation

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Relation

fn deserialize<__D>( __deserializer: __D, ) -> Result<Relation, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Relation

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.