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 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 consciousness_aware_embeddings::AttentionMechanism;

pub use consciousness_aware_embeddings::ConsciousnessAwareEmbedding;

pub use consciousness_aware_embeddings::ConsciousnessInsights;

pub use consciousness_aware_embeddings::ConsciousnessLevel;

pub use consciousness_aware_embeddings::MetaCognition;

pub use consciousness_aware_embeddings::WorkingMemory;

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::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 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::CommunicationBackend;

pub use distributed_training::DistributedEmbeddingTrainer;

pub use distributed_training::DistributedStrategy;

pub use distributed_training::DistributedTrainingConfig;

pub use distributed_training::DistributedTrainingCoordinator;

pub use distributed_training::DistributedTrainingStats;

pub use distributed_training::FaultToleranceConfig;

pub use distributed_training::WorkerInfo;

pub use distributed_training::WorkerStatus;

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 quantum_circuits::Complex;

pub use quantum_circuits::MeasurementStrategy;

pub use quantum_circuits::QNNLayerType;

pub use quantum_circuits::QuantumApproximateOptimization;

pub use quantum_circuits::QuantumCircuit;

pub use quantum_circuits::QuantumGate;

pub use quantum_circuits::QuantumNeuralNetwork;

pub use quantum_circuits::QuantumNeuralNetworkLayer;

pub use quantum_circuits::QuantumSimulator;

pub use quantum_circuits::VariationalQuantumEigensolver;

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

acceleration

Hardware acceleration modules for embedding computations

adaptive_learning

Adaptive Learning System for Real-Time Embedding Enhancement

advanced_profiler

Advanced Performance Profiler

api

RESTful and GraphQL API endpoints for embedding services

application_tasks

Application-specific evaluation tasks for embedding models

batch_processing

Offline batch embedding generation with incremental updates

biological_computing

Biological Computing for Knowledge Graph Embeddings

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

consciousness_aware_embeddings

Consciousness-Aware Embedding System

contextual

Contextual embeddings module - refactored for maintainability

continual_learning

Continual Learning Capabilities

cross_domain_transfer

Cross-domain transfer learning for embedding models

cross_module_performance

Cross-Module Performance Coordinator

delta

Delta computation and incremental update system for embeddings

diffusion_embeddings

Diffusion Model-Based Knowledge Graph Embeddings

distributed_training

Distributed Training Module for Knowledge Graph Embeddings

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_tuning

Fine-tuning Capabilities for Pre-trained Embedding Models

gpu_acceleration

GPU acceleration and optimization features for embedding models

graphql_api

Advanced GraphQL API for embedding queries and management

inference

High-performance inference engine for embedding models

integration

Integration utilities with other OxiRS components

interpretability

Model Interpretability Tools

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

performance_profiler

Performance Profiling for Embedding Operations

persistence

Model persistence and serialization utilities

quantization

Quantization Support for Model Compression

quantum_circuits

Advanced Quantum Circuit Implementations for Quantum-Inspired Embeddings

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

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

training

Training utilities and advanced optimizers for embedding models

utils

Utility functions and helpers for embedding operations

vector_search

Vector Search Integration

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