Struct TransE 

pub struct TransE { /* private fields */ }

TransE embedding model

Implementations

impl TransE

pub fn new(config: ModelConfig) -> Self

Create a new TransE model

pub fn with_l1_distance(config: ModelConfig) -> Self

Create a new TransE model with L1 (Manhattan) distance metric

pub fn with_l2_distance(config: ModelConfig) -> Self

Create a new TransE model with L2 (Euclidean) distance metric

pub fn with_cosine_distance(config: ModelConfig) -> Self

Create a new TransE model with Cosine distance metric

pub fn with_margin(config: ModelConfig, margin: f64) -> Self

Create a new TransE model with custom margin for ranking loss

pub fn distance_metric(&self) -> DistanceMetric

Get the current distance metric

pub fn margin(&self) -> f64

Get the current margin value

Trait Implementations

impl Clone for TransE

fn clone(&self) -> TransE

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransE

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

Formats the value using the given formatter.

impl Default for TransE

fn default() -> Self

Create a TransE model using ModelConfig::default (100-dimensional embeddings, L2 distance, margin 1.0, learning rate 0.01).

This mirrors the construction already used for “give me a TransE model” call sites elsewhere in the crate (e.g. the model registry in persistence.rs), and exists so TransE can satisfy generic bounds like M: EmbeddingModel + Default used by quick smoke-test harnesses such as crate::evaluation::kgc_evaluator::KgcEvaluationSuite::run_on_synthetic. Callers that care about a specific embedding dimension or learning rate should use TransE::new with an explicit ModelConfig instead.

impl EmbeddingModel for TransE

fn config(&self) -> &ModelConfig

fn model_id(&self) -> &Uuid

fn model_type(&self) -> &'static str

fn add_triple(&mut self, triple: Triple) -> Result<()>

fn train<'life0, 'async_trait>( &'life0 mut self, epochs: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<TrainingStats>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_entity_embedding(&self, entity: &str) -> Result<Vector>

fn get_relation_embedding(&self, relation: &str) -> Result<Vector>

fn score_triple( &self, subject: &str, predicate: &str, object: &str, ) -> Result<f64>

fn predict_objects( &self, subject: &str, predicate: &str, k: usize, ) -> Result<Vec<(String, f64)>>

fn predict_subjects( &self, predicate: &str, object: &str, k: usize, ) -> Result<Vec<(String, f64)>>

fn predict_relations( &self, subject: &str, object: &str, k: usize, ) -> Result<Vec<(String, f64)>>

fn get_entities(&self) -> Vec<String>

fn get_relations(&self) -> Vec<String>

fn get_stats(&self) -> ModelStats

fn save(&self, path: &str) -> Result<()>

fn load(&mut self, path: &str) -> Result<()>

fn clear(&mut self)

fn is_trained(&self) -> bool

fn encode<'life0, 'life1, 'async_trait>( &'life0 self, _texts: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<Vec<f32>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Encode text strings into embeddings