Struct RotatEScoring 

pub struct RotatEScoring {
    pub entity_re: Array2<f64>,
    pub entity_im: Array2<f64>,
    pub relation_phase: Array2<f64>,
    pub n_entities: usize,
    pub n_relations: usize,
    pub dim: usize,
}

RotatE scoring model (Sun et al. 2019).

Entity embeddings are complex-valued: each entity e has a real part entity_re[e] and an imaginary part entity_im[e], both of shape (n_entities, dim/2) (so the full complex embedding has dim real parameters per entity).

Relation embeddings are phase angles θ_r ∈ (−π, π] of shape (n_relations, dim/2). The unit-modulus rotation vector is r_e = cos(θ_r) + i sin(θ_r).

Score function (negated L2 in complex space):

  score(h, r, t) = − ‖ h_re ⊙ cos(θ_r) − h_im ⊙ sin(θ_r) − t_re
                      + i ( h_re ⊙ sin(θ_r) + h_im ⊙ cos(θ_r) − t_im ) ‖

Higher scores (less negative) imply a more plausible triple.

Fields

entity_re: Array2<f64>

Real part of entity embeddings (n_entities, dim).

entity_im: Array2<f64>

Imaginary part of entity embeddings (n_entities, dim).

relation_phase: Array2<f64>

Relation phase angles (n_relations, dim).

n_entities: usize

Number of entities.

n_relations: usize

Number of relation types.

dim: usize

Half-embedding dimension (complex degree of freedom per entity/relation).

Implementations

impl RotatEScoring

pub fn new(n_entities: usize, n_relations: usize, dim: usize) -> Self

Create a new RotatE model with random initialisation.

Entity embeddings are Xavier-initialised; relation phases are uniform in (−π, π].

Arguments

• n_entities – Number of distinct entities.
• n_relations – Number of distinct relation types.
• dim – Complex embedding half-dimension (full parameter count per entity is 2 * dim).

pub fn score_triple(&self, h: usize, r: usize, t: usize) -> f64

Compute the RotatE score for triple (h, r, t).

Returns the negated L2 norm of h ∘ r − t in complex space. Scores closer to 0 indicate a more plausible triple.

Trait Implementations

impl Clone for RotatEScoring

fn clone(&self) -> RotatEScoring

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RotatEScoring

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

Formats the value using the given formatter.

impl KgScorer for RotatEScoring

fn score(&self, h: usize, r: usize, t: usize) -> f64

Return a scalar score for the triple (h, r, t).