Struct RotatE 

pub struct RotatE { /* private fields */ }

RotatE: rotation in complex space.

Entities are complex vectors. Relations are element-wise rotations (unit-modulus complex numbers parameterized by angles).

Score: ||head * relation - tail||_2 where * is element-wise complex multiplication and |relation_i| = 1.

Initialization: entities from Uniform(-gamma/sqrt(dim), gamma/sqrt(dim)), relation angles from Uniform(-pi, pi).

Reference: Sun et al. (2019), “RotatE: Knowledge Graph Embedding by Relational Rotation in Complex Space.”

Implementations

impl RotatE

pub fn new( num_entities: usize, num_relations: usize, dim: usize, gamma: f32, ) -> Self

Create a new RotatE model with random initialization.

dim is the complex dimension (each entity stores 2 * dim floats). gamma is the margin, used to scale entity initialization to Uniform(-gamma/sqrt(dim), gamma/sqrt(dim)).

pub fn from_vecs( entities: Vec<Vec<f32>>, relation_angles: Vec<Vec<f32>>, dim: usize, gamma: f32, ) -> Self

Create from pre-built embedding vectors.

entities must have inner length dim * 2 (interleaved re/im). relation_angles must have inner length dim.

Panics

Panics if any dimension is wrong.

pub fn entities(&self) -> &[Vec<f32>]

Entity embeddings: [re..., im...] contiguous layout.

pub fn relation_angles(&self) -> &[Vec<f32>]

Relation angles.

pub fn dim(&self) -> usize

Complex dimension.

pub fn gamma(&self) -> f32

Margin parameter.

pub fn score_triple(&self, head: usize, relation: usize, tail: usize) -> f32

Score a triple by ||h * r - t||_2 in complex space.

Entity layout: first dim floats are real parts, next dim are imaginary.

Trait Implementations

impl Scorer for RotatE

fn score(&self, head: usize, relation: usize, tail: usize) -> f32

Score a triple (head, relation, tail). Lower = more likely.

fn num_entities(&self) -> usize

Number of entities in the model.

fn score_all_tails(&self, head: usize, relation: usize) -> Vec<f32>

Score all entities as tail replacements for (head, relation, ?).

fn score_all_heads(&self, relation: usize, tail: usize) -> Vec<f32>

Score all entities as head replacements for (?, relation, tail).

fn top_k_tails( &self, head: usize, relation: usize, k: usize, ) -> Vec<(usize, f32)>

Return the top-k entities by score for (head, relation, ?).

fn top_k_heads( &self, relation: usize, tail: usize, k: usize, ) -> Vec<(usize, f32)>

Return the top-k entities by score for (?, relation, tail).