oxirs-embed 0.3.1

Knowledge graph embeddings with TransE, ComplEx, and custom models
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

//! Common types, enums, and config structs for embedding utilities

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::Duration;

/// Dataset split result
#[derive(Debug, Clone)]
pub struct DatasetSplit {
    pub train: Vec<(String, String, String)>,
    pub validation: Vec<(String, String, String)>,
    pub test: Vec<(String, String, String)>,
}

/// Statistics about a dataset
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DatasetStatistics {
    pub num_triples: usize,
    pub num_entities: usize,
    pub num_relations: usize,
    pub entity_frequency: HashMap<String, usize>,
    pub relation_frequency: HashMap<String, usize>,
    pub avg_degree: f64,
    pub density: f64,
}

/// Embedding distribution statistics
#[derive(Debug, Clone)]
pub struct EmbeddingDistributionStats {
    pub mean: f64,
    pub std_dev: f64,
    pub variance: f64,
    pub min: f64,
    pub max: f64,
    pub median: f64,
    pub num_parameters: usize,
}

/// Similarity statistics
#[derive(Debug, Clone)]
pub struct SimilarityStats {
    pub mean_similarity: f64,
    pub min_similarity: f64,
    pub max_similarity: f64,
    pub median_similarity: f64,
    pub num_comparisons: usize,
}

/// Graph metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GraphMetrics {
    pub num_entities: usize,
    pub num_relations: usize,
    pub num_triples: usize,
    pub avg_degree: f64,
    pub max_degree: usize,
    pub min_degree: usize,
    pub density: f64,
}

/// Benchmarking configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BenchmarkConfig {
    /// Number of warmup iterations
    pub warmup_iterations: usize,
    /// Number of measurement iterations
    pub measurement_iterations: usize,
    /// Target confidence level (0.0-1.0)
    pub confidence_level: f64,
    /// Enable memory profiling
    pub enable_memory_profiling: bool,
    /// Enable detailed timing analysis
    pub enable_detailed_timing: bool,
}

impl Default for BenchmarkConfig {
    fn default() -> Self {
        Self {
            warmup_iterations: 100,
            measurement_iterations: 1000,
            confidence_level: 0.95,
            enable_memory_profiling: true,
            enable_detailed_timing: true,
        }
    }
}

/// Memory usage statistics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryStats {
    /// Peak memory usage (bytes)
    pub peak_memory_bytes: usize,
    /// Average memory usage (bytes)
    pub avg_memory_bytes: usize,
    /// Memory allocations count
    pub allocations: usize,
    /// Memory deallocations count
    pub deallocations: usize,
}

/// Individual benchmark result for a specific operation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BenchmarkResult {
    /// Operation name
    pub operation: String,
    /// Total number of iterations
    pub iterations: usize,
    /// Total elapsed time
    pub total_duration: Duration,
    /// Average time per operation
    pub avg_duration: Duration,
    /// Minimum time observed
    pub min_duration: Duration,
    /// Maximum time observed
    pub max_duration: Duration,
    /// Standard deviation of durations
    pub std_deviation: Duration,
    /// Operations per second
    pub ops_per_second: f64,
    /// Memory usage statistics
    pub memory_stats: MemoryStats,
    /// Additional metrics
    pub custom_metrics: HashMap<String, f64>,
}

/// Overall benchmark summary
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BenchmarkSummary {
    /// Total benchmark duration
    pub total_duration: Duration,
    /// Number of operations benchmarked
    pub total_operations: usize,
    /// Overall throughput (ops/sec)
    pub overall_throughput: f64,
    /// Performance efficiency score (0.0-1.0)
    pub efficiency_score: f64,
    /// Bottleneck analysis
    pub bottlenecks: Vec<String>,
}

/// Benchmark comparison result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BenchmarkComparison {
    pub baseline_name: String,
    pub comparison_name: String,
    pub throughput_improvement: f64,
    pub latency_improvement: f64,
    pub consistency_improvement: f64,
    pub is_improvement: bool,
}

/// Performance regression analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RegressionAnalysis {
    pub throughput_change: f64,
    pub is_regression: bool,
    pub confidence_level: f64,
    pub analysis_notes: Vec<String>,
}

impl Default for RegressionAnalysis {
    fn default() -> Self {
        Self {
            throughput_change: 0.0,
            is_regression: false,
            confidence_level: 0.0,
            analysis_notes: vec!["No historical data available".to_string()],
        }
    }
}