Crate oxirs_embed 

OxiRS Embed: Advanced Knowledge Graph Embeddings

Status: Production Release (v0.1.0) Stability: Public APIs are stable. Production-ready with comprehensive testing.

State-of-the-art knowledge graph embedding methods including TransE, DistMult, ComplEx, and RotatE models, enhanced with biomedical AI, GPU acceleration, and specialized text processing.

Key Features

🧬 Biomedical AI

• Specialized biomedical knowledge graph embeddings
• Gene-disease association prediction
• Drug-target interaction modeling
• Pathway analysis and protein interactions
• Domain-specific text embeddings (SciBERT, BioBERT, etc.)

🚀 GPU Acceleration

• Advanced GPU memory pooling and management
• Intelligent tensor caching
• Mixed precision training and inference
• Multi-stream parallel processing
• Pipeline parallelism for large-scale training

🤖 Advanced Models

• Traditional KG embeddings (TransE, DistMult, ComplEx, RotatE, etc.)
• Graph Neural Networks (GCN, GraphSAGE, GAT)
• Transformer-based embeddings with fine-tuning
• Ontology-aware embeddings with reasoning

📊 Production-Ready

• Comprehensive evaluation and benchmarking
• Model registry and version management
• Intelligent caching and optimization
• API server for deployment

Quick Start

use oxirs_embed::{TransE, ModelConfig, Triple, NamedNode, EmbeddingModel};

// Create a knowledge graph embedding model
let config = ModelConfig::default().with_dimensions(128);
let mut model = TransE::new(config);

// Add knowledge triples
let triple = Triple::new(
    NamedNode::new("http://example.org/alice")?,
    NamedNode::new("http://example.org/knows")?,
    NamedNode::new("http://example.org/bob")?,
);
model.add_triple(triple)?;

// Train the model
let stats = model.train(Some(100)).await?;
println!("Training completed: {stats:?}");

Biomedical Example

use oxirs_embed::{BiomedicalEmbedding, BiomedicalEmbeddingConfig, EmbeddingModel};

// Create biomedical embedding model
let config = BiomedicalEmbeddingConfig::default();
let mut model = BiomedicalEmbedding::new(config);

// Add biomedical knowledge
model.add_gene_disease_association("BRCA1", "breast_cancer", 0.95);
model.add_drug_target_interaction("aspirin", "COX1", 0.92);

// Train and predict
model.train(Some(100)).await?;
let predictions = model.predict_gene_disease_associations("BRCA1", 5)?;

GPU Acceleration Example

use oxirs_embed::{GpuAccelerationConfig, GpuAccelerationManager};

// Configure GPU acceleration
let config = GpuAccelerationConfig {
    enabled: true,
    mixed_precision: true,
    tensor_caching: true,
    multi_stream: true,
    num_streams: 4,
    ..Default::default()
};

let mut gpu_manager = GpuAccelerationManager::new(config);

// Use accelerated embedding generation
let entities = vec!["entity1".to_string(), "entity2".to_string()];
let embeddings = gpu_manager.accelerated_embedding_generation(
    entities,
    |entity| { /* compute embedding */ vec![0.0; 128].into() }
).await?;

Examples

See the examples/ directory for comprehensive demonstrations:

• biomedical_embedding_demo.rs - Biomedical AI capabilities
• gpu_acceleration_demo.rs - GPU acceleration features
• integrated_ai_platform_demo.rs - Complete AI platform showcase

Re-exports

pub use projection_layer::ActivationFn;

pub use projection_layer::InitMethod;

pub use projection_layer::ProjectionLayer;

pub use projection_layer::ProjectionMatrix;

pub use adaptive_learning::AdaptationMetrics;

pub use adaptive_learning::AdaptationStrategy;

pub use adaptive_learning::AdaptiveLearningConfig;

pub use adaptive_learning::AdaptiveLearningSystem;

pub use adaptive_learning::QualityFeedback;

pub use acceleration::AdaptiveEmbeddingAccelerator;

pub use acceleration::GpuEmbeddingAccelerator;

pub use api::start_server;

pub use api::ApiConfig;

pub use api::ApiState;

pub use batch_processing::BatchJob;

pub use batch_processing::BatchProcessingConfig;

pub use batch_processing::BatchProcessingManager;

pub use batch_processing::BatchProcessingResult;

pub use batch_processing::BatchProcessingStats;

pub use batch_processing::IncrementalConfig;

pub use batch_processing::JobProgress;

pub use batch_processing::JobStatus;

pub use batch_processing::OutputFormat;

pub use batch_processing::PartitioningStrategy;

pub use batch_processing::RetryConfig;

pub use biomedical_embeddings::BiomedicalEmbedding;

pub use biomedical_embeddings::BiomedicalEmbeddingConfig;

pub use biomedical_embeddings::BiomedicalEntityType;

pub use biomedical_embeddings::BiomedicalRelationType;

pub use biomedical_embeddings::FineTuningConfig;

pub use biomedical_embeddings::PreprocessingRule;

pub use biomedical_embeddings::SpecializedTextConfig;

pub use biomedical_embeddings::SpecializedTextEmbedding;

pub use biomedical_embeddings::SpecializedTextModel;

pub use caching::CacheConfig;

pub use caching::CacheManager;

pub use caching::CachedEmbeddingModel;

pub use causal_representation_learning::CausalDiscoveryAlgorithm;

pub use causal_representation_learning::CausalDiscoveryConfig;

pub use causal_representation_learning::CausalGraph;

pub use causal_representation_learning::CausalRepresentationConfig;

pub use causal_representation_learning::CausalRepresentationModel;

pub use causal_representation_learning::ConstraintSettings;

pub use causal_representation_learning::CounterfactualConfig;

pub use causal_representation_learning::CounterfactualQuery;

pub use causal_representation_learning::DisentanglementConfig;

pub use causal_representation_learning::DisentanglementMethod;

pub use causal_representation_learning::ExplanationType;

pub use causal_representation_learning::IndependenceTest;

pub use causal_representation_learning::InterventionConfig;

pub use causal_representation_learning::ScoreSettings;

pub use causal_representation_learning::StructuralCausalModelConfig;

pub use cloud_integration::AWSSageMakerService;

pub use cloud_integration::AutoScalingConfig;

pub use cloud_integration::AzureMLService;

pub use cloud_integration::BackupConfig;

pub use cloud_integration::CloudIntegrationConfig;

pub use cloud_integration::CloudIntegrationManager;

pub use cloud_integration::CloudProvider;

pub use cloud_integration::CloudService;

pub use cloud_integration::ClusterStatus;

pub use cloud_integration::CostEstimate;

pub use cloud_integration::CostOptimizationResult;

pub use cloud_integration::CostOptimizationStrategy;

pub use cloud_integration::DeploymentConfig;

pub use cloud_integration::DeploymentResult;

pub use cloud_integration::DeploymentStatus;

pub use cloud_integration::EndpointInfo;

pub use cloud_integration::FunctionInvocationResult;

pub use cloud_integration::GPUClusterConfig;

pub use cloud_integration::GPUClusterResult;

pub use cloud_integration::LifecyclePolicy;

pub use cloud_integration::OptimizationAction;

pub use cloud_integration::PerformanceTier;

pub use cloud_integration::ReplicationType;

pub use cloud_integration::ServerlessDeploymentResult;

pub use cloud_integration::ServerlessFunctionConfig;

pub use cloud_integration::ServerlessStatus;

pub use cloud_integration::StorageConfig;

pub use cloud_integration::StorageResult;

pub use cloud_integration::StorageStatus;

pub use cloud_integration::StorageType;

pub use compression::CompressedModel;

pub use compression::CompressionStats;

pub use compression::CompressionTarget;

pub use compression::DistillationConfig;

pub use compression::ModelCompressionManager;

pub use compression::NASConfig;

pub use compression::OptimizationTarget;

pub use compression::PruningConfig;

pub use compression::PruningMethod;

pub use compression::QuantizationConfig;

pub use compression::QuantizationMethod;

pub use continual_learning::ArchitectureConfig;

pub use continual_learning::BoundaryDetection;

pub use continual_learning::ConsolidationConfig;

pub use continual_learning::ContinualLearningConfig;

pub use continual_learning::ContinualLearningModel;

pub use continual_learning::MemoryConfig;

pub use continual_learning::MemoryType;

pub use continual_learning::MemoryUpdateStrategy;

pub use continual_learning::RegularizationConfig;

pub use continual_learning::ReplayConfig;

pub use continual_learning::ReplayMethod;

pub use continual_learning::TaskConfig;

pub use continual_learning::TaskDetection;

pub use continual_learning::TaskSwitching;

pub use cross_module_performance::CoordinatorConfig;

pub use cross_module_performance::CrossModulePerformanceCoordinator;

pub use cross_module_performance::GlobalPerformanceMetrics;

pub use cross_module_performance::ModuleMetrics;

pub use cross_module_performance::ModulePerformanceMonitor;

pub use cross_module_performance::OptimizationCache;

pub use cross_module_performance::PerformanceSnapshot;

pub use cross_module_performance::PredictivePerformanceEngine;

pub use cross_module_performance::ResourceAllocator;

pub use cross_module_performance::ResourceTracker;

pub use delta::ChangeRecord;

pub use delta::ChangeStatistics;

pub use delta::ChangeType;

pub use delta::DeltaConfig;

pub use delta::DeltaManager;

pub use delta::DeltaResult;

pub use delta::DeltaStats;

pub use delta::IncrementalStrategy;

pub use enterprise_knowledge::BehaviorMetrics;

pub use enterprise_knowledge::CareerPredictions;

pub use enterprise_knowledge::Category;

pub use enterprise_knowledge::CategoryHierarchy;

pub use enterprise_knowledge::CategoryPerformance;

pub use enterprise_knowledge::ColdStartStrategy;

pub use enterprise_knowledge::CommunicationFrequency;

pub use enterprise_knowledge::CommunicationPreferences;

pub use enterprise_knowledge::CustomerEmbedding;

pub use enterprise_knowledge::CustomerPreferences;

pub use enterprise_knowledge::CustomerRatings;

pub use enterprise_knowledge::CustomerSegment;

pub use enterprise_knowledge::Department;

pub use enterprise_knowledge::DepartmentPerformance;

pub use enterprise_knowledge::EmployeeEmbedding;

pub use enterprise_knowledge::EnterpriseConfig;

pub use enterprise_knowledge::EnterpriseKnowledgeAnalyzer;

pub use enterprise_knowledge::EnterpriseMetrics;

pub use enterprise_knowledge::ExperienceLevel;

pub use enterprise_knowledge::FeatureType;

pub use enterprise_knowledge::MarketAnalysis;

pub use enterprise_knowledge::OrganizationalStructure;

pub use enterprise_knowledge::PerformanceMetrics as EnterprisePerformanceMetrics;

pub use enterprise_knowledge::ProductAvailability;

pub use enterprise_knowledge::ProductEmbedding;

pub use enterprise_knowledge::ProductFeature;

pub use enterprise_knowledge::ProductRecommendation;

pub use enterprise_knowledge::Project;

pub use enterprise_knowledge::ProjectOutcome;

pub use enterprise_knowledge::ProjectParticipation;

pub use enterprise_knowledge::ProjectPerformance;

pub use enterprise_knowledge::ProjectStatus;

pub use enterprise_knowledge::Purchase;

pub use enterprise_knowledge::PurchaseChannel;

pub use enterprise_knowledge::RecommendationConfig;

pub use enterprise_knowledge::RecommendationEngine;

pub use enterprise_knowledge::RecommendationEngineType;

pub use enterprise_knowledge::RecommendationPerformance;

pub use enterprise_knowledge::RecommendationReason;

pub use enterprise_knowledge::SalesMetrics;

pub use enterprise_knowledge::Skill;

pub use enterprise_knowledge::SkillCategory;

pub use enterprise_knowledge::Team;

pub use enterprise_knowledge::TeamPerformance;

pub use evaluation::AnalogicalReasoningBenchmark;

pub use evaluation::AnalogyQuad;

pub use evaluation::EmbeddingClusteringMetrics;

pub use evaluation::EmbeddingEvaluator;

pub use evaluation::QueryAnsweringEvaluator;

pub use evaluation::QueryEvaluationConfig;

pub use evaluation::QueryEvaluationResults;

pub use evaluation::QueryMetric;

pub use evaluation::QueryResult;

pub use evaluation::QueryTemplate;

pub use evaluation::QueryType;

pub use evaluation::ReasoningChain;

pub use evaluation::ReasoningEvaluationConfig;

pub use evaluation::ReasoningEvaluationResults;

pub use evaluation::ReasoningRule;

pub use evaluation::ReasoningStep;

pub use evaluation::ReasoningTaskEvaluator;

pub use evaluation::ReasoningType;

pub use evaluation::TypeSpecificResults;

pub use federated_learning::AggregationEngine;

pub use federated_learning::AggregationStrategy;

pub use federated_learning::AuthenticationConfig;

pub use federated_learning::AuthenticationMethod;

pub use federated_learning::CertificateConfig;

pub use federated_learning::ClippingMechanisms;

pub use federated_learning::ClippingMethod;

pub use federated_learning::CommunicationConfig;

pub use federated_learning::CommunicationManager;

pub use federated_learning::CommunicationProtocol;

pub use federated_learning::CompressionAlgorithm;

pub use federated_learning::CompressionConfig;

pub use federated_learning::CompressionEngine;

pub use federated_learning::ConvergenceMetrics;

pub use federated_learning::ConvergenceStatus;

pub use federated_learning::DataSelectionStrategy;

pub use federated_learning::DataStatistics;

pub use federated_learning::EncryptionScheme;

pub use federated_learning::FederatedConfig;

pub use federated_learning::FederatedCoordinator;

pub use federated_learning::FederatedEmbeddingModel;

pub use federated_learning::FederatedMessage;

pub use federated_learning::FederatedRound;

pub use federated_learning::FederationStats;

pub use federated_learning::GlobalModelState;

pub use federated_learning::HardwareAccelerator;

pub use federated_learning::KeyManager;

pub use federated_learning::LocalModelState;

pub use federated_learning::LocalTrainingStats;

pub use federated_learning::LocalUpdate;

pub use federated_learning::MetaLearningConfig;

pub use federated_learning::NoiseGenerator;

pub use federated_learning::NoiseMechanism;

pub use federated_learning::OutlierAction;

pub use federated_learning::OutlierDetection;

pub use federated_learning::OutlierDetectionMethod;

pub use federated_learning::Participant;

pub use federated_learning::ParticipantCapabilities;

pub use federated_learning::ParticipantStatus;

pub use federated_learning::PersonalizationConfig;

pub use federated_learning::PersonalizationStrategy;

pub use federated_learning::PrivacyAccountant;

pub use federated_learning::PrivacyConfig;

pub use federated_learning::PrivacyEngine;

pub use federated_learning::PrivacyMetrics;

pub use federated_learning::PrivacyParams;

pub use federated_learning::RoundMetrics;

pub use federated_learning::RoundStatus;

pub use federated_learning::SecurityConfig;

pub use federated_learning::SecurityFeature;

pub use federated_learning::SecurityManager;

pub use federated_learning::TrainingConfig;

pub use federated_learning::VerificationEngine;

pub use federated_learning::VerificationMechanism;

pub use federated_learning::VerificationResult;

pub use federated_learning::WeightingScheme;

pub use gpu_acceleration::GpuAccelerationConfig;

pub use gpu_acceleration::GpuAccelerationManager;

pub use gpu_acceleration::GpuMemoryPool;

pub use gpu_acceleration::GpuPerformanceStats;

pub use gpu_acceleration::MixedPrecisionProcessor;

pub use gpu_acceleration::MultiStreamProcessor;

pub use gpu_acceleration::TensorCache;

pub use graphql_api::create_schema;

pub use graphql_api::BatchEmbeddingInput;

pub use graphql_api::BatchEmbeddingResult;

pub use graphql_api::BatchStatus;

pub use graphql_api::DistanceMetric;

pub use graphql_api::EmbeddingFormat;

pub use graphql_api::EmbeddingQueryInput;

pub use graphql_api::EmbeddingResult;

pub use graphql_api::EmbeddingSchema;

pub use graphql_api::GraphQLContext;

pub use graphql_api::ModelInfo;

pub use graphql_api::ModelType;

pub use graphql_api::SimilarityResult;

pub use graphql_api::SimilaritySearchInput;

pub use kg_completion::BatchedTrainingLoop;

pub use kg_completion::KgCompletionTask;

pub use kg_completion::NegativeSampler;

pub use kg_completion::TrainingBatch;

pub use models::AggregationType;

pub use models::ComplEx;

pub use models::DistMult;

pub use models::GNNConfig;

pub use models::GNNEmbedding;

pub use models::GNNType;

pub use models::HoLE;

pub use models::HoLEConfig;

pub use models::PoolingStrategy;

pub use models::RotatE;

pub use models::TransE;

pub use models::TransformerConfig;

pub use models::TransformerEmbedding;

pub use models::TransformerType;

pub use contextual::AccessibilityPreferences;

pub use contextual::ComplexityLevel;

pub use contextual::ContextualConfig;

pub use contextual::ContextualEmbeddingModel;

pub use contextual::DomainContext;

pub use contextual::EmbeddingContext;

pub use contextual::PerformanceRequirements;

pub use contextual::PriorityLevel;

pub use contextual::PrivacySettings;

pub use contextual::QueryContext;

pub use contextual::QueryType as ContextualQueryType;

pub use contextual::ResponseFormat;

pub use contextual::TaskConstraints;

pub use contextual::TaskContext;

pub use contextual::TaskType;

pub use contextual::UserContext;

pub use contextual::UserHistory;

pub use contextual::UserPreferences;

pub use distributed_training::AggregationMethod;

pub use distributed_training::AllReduceStrategy;

pub use distributed_training::CommunicationBackend;

pub use distributed_training::DataParallelTrainer;

pub use distributed_training::DistributedEmbeddingTrainer;

pub use distributed_training::DistributedStrategy;

pub use distributed_training::DistributedTrainingConfig;

pub use distributed_training::DistributedTrainingCoordinator;

pub use distributed_training::DistributedTrainingSample;

pub use distributed_training::DistributedTrainingStats;

pub use distributed_training::FaultToleranceConfig;

pub use distributed_training::GradientAggregator;

pub use distributed_training::GradientCompressor;

pub use distributed_training::ModelUpdate;

pub use distributed_training::SparseGradient;

pub use distributed_training::WorkerInfo;

pub use distributed_training::WorkerStatus;

pub use distributed_training::WorkerUpdate;

pub use models::ConvE;

pub use models::ConvEConfig;

pub use monitoring::Alert;

pub use monitoring::AlertSeverity;

pub use monitoring::AlertThresholds;

pub use monitoring::AlertType;

pub use monitoring::CacheMetrics;

pub use monitoring::ConsoleAlertHandler;

pub use monitoring::DriftMetrics;

pub use monitoring::ErrorEvent;

pub use monitoring::ErrorMetrics;

pub use monitoring::ErrorSeverity;

pub use monitoring::LatencyMetrics;

pub use monitoring::MonitoringConfig;

pub use monitoring::PerformanceMetrics as MonitoringPerformanceMetrics;

pub use monitoring::PerformanceMonitor;

pub use monitoring::QualityAssessment;

pub use monitoring::QualityMetrics;

pub use monitoring::ResourceMetrics;

pub use monitoring::SlackAlertHandler;

pub use monitoring::ThroughputMetrics;

pub use multimodal::AlignmentNetwork;

pub use multimodal::AlignmentObjective;

pub use multimodal::ContrastiveConfig;

pub use multimodal::CrossDomainConfig;

pub use multimodal::CrossModalConfig;

pub use multimodal::KGEncoder;

pub use multimodal::MultiModalEmbedding;

pub use multimodal::MultiModalStats;

pub use multimodal::TextEncoder;

pub use neural_symbolic_integration::ConstraintSatisfactionConfig;

pub use neural_symbolic_integration::ConstraintType;

pub use neural_symbolic_integration::KnowledgeIntegrationConfig;

pub use neural_symbolic_integration::KnowledgeRule;

pub use neural_symbolic_integration::LogicIntegrationConfig;

pub use neural_symbolic_integration::LogicProgrammingConfig;

pub use neural_symbolic_integration::LogicalFormula;

pub use neural_symbolic_integration::NeuralSymbolicConfig;

pub use neural_symbolic_integration::NeuralSymbolicModel;

pub use neural_symbolic_integration::NeuroSymbolicArchitectureConfig;

pub use neural_symbolic_integration::OntologicalConfig;

pub use neural_symbolic_integration::ReasoningEngine;

pub use neural_symbolic_integration::RuleBasedConfig;

pub use neural_symbolic_integration::SymbolicReasoningConfig;

pub use novel_architectures::ActivationType;

pub use novel_architectures::ArchitectureParams;

pub use novel_architectures::ArchitectureState;

pub use novel_architectures::ArchitectureType;

pub use novel_architectures::CurvatureComputation;

pub use novel_architectures::CurvatureMethod;

pub use novel_architectures::CurvatureType;

pub use novel_architectures::DynamicsConfig;

pub use novel_architectures::EntanglementStructure;

pub use novel_architectures::EquivarianceGroup;

pub use novel_architectures::FlowType;

pub use novel_architectures::GeometricConfig;

pub use novel_architectures::GeometricParams;

pub use novel_architectures::GeometricSpace;

pub use novel_architectures::GeometricState;

pub use novel_architectures::GraphTransformerParams;

pub use novel_architectures::GraphTransformerState;

pub use novel_architectures::HyperbolicDistance;

pub use novel_architectures::HyperbolicInit;

pub use novel_architectures::HyperbolicManifold;

pub use novel_architectures::HyperbolicParams;

pub use novel_architectures::HyperbolicState;

pub use novel_architectures::IntegrationScheme;

pub use novel_architectures::IntegrationStats;

pub use novel_architectures::ManifoldLearning;

pub use novel_architectures::ManifoldMethod;

pub use novel_architectures::ManifoldOptimizer;

pub use novel_architectures::NeuralODEParams;

pub use novel_architectures::NeuralODEState;

pub use novel_architectures::NovelArchitectureConfig;

pub use novel_architectures::NovelArchitectureModel;

pub use novel_architectures::ODERegularization;

pub use novel_architectures::ODESolverType;

pub use novel_architectures::ParallelTransport;

pub use novel_architectures::QuantumGateSet;

pub use novel_architectures::QuantumMeasurement;

pub use novel_architectures::QuantumNoise;

pub use novel_architectures::QuantumParams;

pub use novel_architectures::QuantumState;

pub use novel_architectures::StabilityConstraints;

pub use novel_architectures::StructuralBias;

pub use novel_architectures::TimeEvolution;

pub use novel_architectures::TransportMethod;

pub use research_networks::AuthorEmbedding;

pub use research_networks::Citation;

pub use research_networks::CitationNetwork;

pub use research_networks::CitationType;

pub use research_networks::Collaboration;

pub use research_networks::CollaborationNetwork;

pub use research_networks::NetworkMetrics;

pub use research_networks::PaperSection;

pub use research_networks::PublicationEmbedding;

pub use research_networks::PublicationType;

pub use research_networks::ResearchCommunity;

pub use research_networks::ResearchNetworkAnalyzer;

pub use research_networks::ResearchNetworkConfig;

pub use research_networks::TopicModel;

pub use research_networks::TopicModelingConfig;

pub use sparql_extension::ExpandedQuery;

pub use sparql_extension::Expansion;

pub use sparql_extension::ExpansionType;

pub use sparql_extension::QueryStatistics as SparqlQueryStatistics;

pub use sparql_extension::SparqlExtension;

pub use sparql_extension::SparqlExtensionConfig;

pub use storage_backend::DiskBackend;

pub use storage_backend::EmbeddingMetadata;

pub use storage_backend::EmbeddingVersion;

pub use storage_backend::MemoryBackend;

pub use storage_backend::StorageBackend;

pub use storage_backend::StorageBackendConfig;

pub use storage_backend::StorageBackendManager;

pub use storage_backend::StorageBackendType;

pub use storage_backend::StorageStats;

pub use temporal_embeddings::TemporalEmbeddingConfig;

pub use temporal_embeddings::TemporalEmbeddingModel;

pub use temporal_embeddings::TemporalEvent;

pub use temporal_embeddings::TemporalForecast;

pub use temporal_embeddings::TemporalGranularity;

pub use temporal_embeddings::TemporalScope;

pub use temporal_embeddings::TemporalStats;

pub use temporal_embeddings::TemporalTriple;

pub use vision_language_graph::AggregationFunction;

pub use vision_language_graph::CNNConfig;

pub use vision_language_graph::CrossAttentionConfig;

pub use vision_language_graph::DomainAdaptationConfig;

pub use vision_language_graph::DomainAdaptationMethod;

pub use vision_language_graph::EpisodeConfig;

pub use vision_language_graph::FewShotConfig;

pub use vision_language_graph::FewShotMethod;

pub use vision_language_graph::FusionStrategy;

pub use vision_language_graph::GraphArchitecture;

pub use vision_language_graph::GraphEncoder;

pub use vision_language_graph::GraphEncoderConfig;

pub use vision_language_graph::JointTrainingConfig;

pub use vision_language_graph::LanguageArchitecture;

pub use vision_language_graph::LanguageEncoder;

pub use vision_language_graph::LanguageEncoderConfig;

pub use vision_language_graph::LanguageTransformerConfig;

pub use vision_language_graph::MetaLearner;

pub use vision_language_graph::ModalityEncoding;

pub use vision_language_graph::MultiModalTransformer;

pub use vision_language_graph::MultiModalTransformerConfig;

pub use vision_language_graph::NormalizationType;

pub use vision_language_graph::PoolingType;

pub use vision_language_graph::PositionEncodingType;

pub use vision_language_graph::ReadoutFunction;

pub use vision_language_graph::TaskCategory;

pub use vision_language_graph::TaskSpecificParams;

pub use vision_language_graph::TrainingObjective;

pub use vision_language_graph::TransferLearningConfig;

pub use vision_language_graph::TransferStrategy;

pub use vision_language_graph::ViTConfig;

pub use vision_language_graph::VisionArchitecture;

pub use vision_language_graph::VisionEncoder;

pub use vision_language_graph::VisionEncoderConfig;

pub use vision_language_graph::VisionLanguageGraphConfig;

pub use vision_language_graph::VisionLanguageGraphModel;

pub use vision_language_graph::VisionLanguageGraphStats;

pub use vision_language_graph::ZeroShotConfig;

pub use vision_language_graph::ZeroShotMethod;

pub use models::TuckER;

pub use models::QuatD;

pub use crate::model_registry::ModelRegistry;

pub use crate::model_registry::ModelVersion;

pub use crate::model_registry::ResourceAllocation as ModelResourceAllocation;

pub use crate::model_selection::DatasetCharacteristics;

pub use crate::model_selection::MemoryRequirement;

pub use crate::model_selection::ModelComparison;

pub use crate::model_selection::ModelComparisonEntry;

pub use crate::model_selection::ModelRecommendation;

pub use crate::model_selection::ModelSelector;

pub use crate::model_selection::ModelType as SelectionModelType;

pub use crate::model_selection::TrainingTime;

pub use crate::model_selection::UseCaseType;

pub use crate::performance_profiler::OperationStats;

pub use crate::performance_profiler::OperationTimer;

pub use crate::performance_profiler::OperationType;

pub use crate::performance_profiler::PerformanceProfiler;

pub use crate::performance_profiler::PerformanceReport;

Modules

ab_testing

A/B Testing Framework for Embedding Models (v0.3.0)

acceleration

Hardware acceleration modules for embedding computations

adaptive_learning

Adaptive Learning System for Real-Time Embedding Enhancement

advanced_profiler

Advanced Performance Profiler

alignment

Embedding Alignment: Aligning embeddings across different knowledge graph spaces.

api

RESTful and GraphQL API endpoints for embedding services

application_tasks

Application-specific evaluation tasks for embedding models

batch_encoder

Batch text encoding pipeline with chunking and pooling strategies.

batch_processing

Offline batch embedding generation with incremental updates

biomedical_embeddings

Biomedical knowledge graph embeddings for scientific applications

caching

Advanced caching and precomputation system for embedding models

causal_representation_learning

Causal Representation Learning

cloud_integration

Cloud provider integration for embedding services

clustering

Clustering Support for Knowledge Graph Embeddings

community_detection

Community Detection for Knowledge Graphs

compression

Model compression and quantization for efficient embedding deployment

contextual

Contextual embeddings module - refactored for maintainability

continual_learning

Continual Learning Capabilities

contrastive_learning

Contrastive Learning Loss Functions for Knowledge Graph Embeddings

cross_domain_transfer

Cross-domain transfer learning for embedding models

cross_encoder

Cross-encoder re-ranker for embedding search results.

cross_module_performance

Cross-Module Performance Coordinator

delta

Delta computation and incremental update system for embeddings

diffusion_embeddings

Diffusion Model-Based Knowledge Graph Embeddings

dimensionality_reducer

Dimensionality Reducer

distributed_training

Distributed Training Module for Knowledge Graph Embeddings

embed_compression

Embedding Compression: Quantization and Product Quantization for efficient storage and approximate nearest-neighbor search.

embedding_aggregator

Embedding aggregation strategies for combining token-level embeddings.

embedding_cache

LRU embedding cache with memory-bounded eviction and per-model invalidation.

embedding_compressor

Random projection for embedding dimensionality reduction.

embedding_store

In-memory embedding store with label-based lookup and cosine similarity search.

enterprise_knowledge

Enterprise Knowledge Graphs - Business Domain Embeddings

entity_linking

Entity Linking and Relation Prediction for Knowledge Graphs

evaluation

Evaluation module for embeddings and knowledge graphs

federated_learning

Federated learning module with organized sub-modules

fine_tuner

Embedding fine-tuning with contrastive learning (pure Rust, CPU-only).

fine_tuning

Fine-tuning Capabilities for Pre-trained Embedding Models

gpu_acceleration

GPU acceleration and optimization features for embedding models

graph_models

Graph neural network embedding models (v0.3.0).

graphql_api

Advanced GraphQL API for embedding queries and management

index_optimizer

ANN Index Parameter Optimizer

inference

High-performance inference engine for embedding models

integration

Integration utilities with other OxiRS components

interpretability

Model Interpretability Tools

kg_completion

Knowledge Graph Completion: negative sampling and batched training loops.

link_prediction

Link Prediction for Knowledge Graph Completion

mamba_attention

Mamba and State Space Model Attention Mechanisms

mixed_precision

Mixed Precision Training for Knowledge Graph Embeddings

model_registry

Model Registry and Versioning System

model_selection

Model Selection Guidance

models

Embedding model implementations

monitoring

Comprehensive monitoring and metrics system for embedding models

multimodal

Multi-modal embeddings and cross-modal alignment for unified representation learning

neural_symbolic_integration

Neural-Symbolic Integration

neuro_evolution

Neuro-Evolution for Automated Neural Architecture Search

novel_architectures

Novel architectures for cutting-edge embedding techniques

pca_reducer

PCA Reducer

performance_profiler

Performance Profiling for Embedding Operations

persistence

Model persistence and serialization utilities

procrustes_alignment

Procrustes Alignment for Embedding Spaces

projection_layer

Linear embedding projection layer (dimensionality reduction or expansion).

quantization

Quantization Support for Model Compression

quick_start

Convenience functions for quick setup and common operations

real_time_fine_tuning

Real-time Fine-tuning System

real_time_optimization

Real-time optimization system for knowledge graph embeddings

reranker

Result reranking for retrieval pipelines.

research_networks

Research Publication Networks - Academic Knowledge Graph Embeddings

sparql_extension

SPARQL Extension for Advanced Embedding-Enhanced Queries

storage_backend

Storage Backend Integration for Persistent Embeddings

temporal_embeddings

Temporal Embeddings Module for Time-Aware Knowledge Graph Embeddings

tokenizer

Text tokenizer for embeddings.

training

Training utilities and advanced optimizers for embedding models

training_online

Online / incremental embedding training utilities.

utils

Utility functions and helpers for embedding operations

validation

Model validation and integrity checks for embedding models

vector_search

Vector Search Integration

vector_store

In-memory vector store with namespace support.

vision_language_graph

Vision-Language-Graph Multi-Modal Integration

visualization

Embedding Visualization Tools

Structs

ModelConfig

Configuration for embedding models

ModelStats

Model statistics

NamedNode

Named node for RDF resources

TrainingStats

Training statistics

Triple

Triple structure for RDF triples

VecVector

Multi-precision vector with enhanced functionality

Vector

Compatibility wrapper for Vector that provides the old interface while using the sophisticated oxirs-vec Vector internally

Enums

EmbeddingError

Embedding errors

Traits

EmbeddingModel

Basic embedding model trait