Crate oxirs_shacl_ai 

OxiRS SHACL-AI

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

AI-powered SHACL shape learning, validation optimization, and quality assessment.

This crate provides intelligent capabilities for SHACL validation including:

• Automatic shape generation from RDF data
• Constraint discovery and learning
• Validation optimization and prediction
• Data quality assessment and improvement suggestions

Features

• Shape mining and discovery from RDF graphs
• Pattern recognition for constraint generation
• Quality-driven shape optimization
• Predictive validation with error prevention
• Context-aware validation strategies
• Machine learning-based constraint refinement

Basic Usage

use oxirs_shacl_ai::{ShapeLearner, QualityAssessor, LearningConfig};

// Create a shape learner
let mut learner = ShapeLearner::new();

// Create a quality assessor
let mut assessor = QualityAssessor::new();

// Configuration can be customized
let config = LearningConfig::default();

Advanced Shape Learning Examples

Custom Learning Configuration

use oxirs_shacl_ai::{ShapeLearner, LearningConfig};
use std::collections::HashMap;

let config = LearningConfig {
    enable_shape_generation: true,
    min_support: 0.3,           // Higher threshold for more selective patterns
    min_confidence: 0.85,       // Higher confidence for better quality
    max_shapes: 50,             // Limit number of generated shapes
    enable_training: true,      // Enable ML training
    algorithm_params: HashMap::new(),
    enable_reinforcement_learning: true,
    rl_config: None,
};

let mut learner = ShapeLearner::with_config(config);

Performance-Optimized Learning

use oxirs_shacl_ai::{ShapeLearner, LearningConfig, PatternStatistics};
use std::collections::HashMap;

// Configure for high-performance learning
let mut config = LearningConfig::default();
config.min_support = 0.1;      // Lower threshold for comprehensive coverage
config.max_shapes = 200;       // Allow more shapes for complex datasets
config.enable_training = true;

let mut learner = ShapeLearner::with_config(config);

// Monitor learning performance
let stats = learner.get_statistics();
// Statistics can be accessed via stats.total_shapes_learned, stats.failed_shapes, etc.

Integration with OxiRS Core

SHACL Validation Integration

use oxirs_shacl_ai::{ShapeLearner, ValidationPredictor};
use oxirs_shacl::ValidationConfig;

// Create a shape learner
let mut learner = ShapeLearner::new();

// Create a validation predictor for optimization
let predictor = ValidationPredictor::new();

// Configuration for validation
let validation_config = ValidationConfig::default();

// In practice, these would be used with a Store instance
// See examples/ directory for complete working examples

Quantum Consciousness Integration

use oxirs_shacl_ai::{ContainerConfig, DeploymentConfig, DeploymentManager};
use oxirs_shacl_ai::deployment::EnvironmentType;
use oxirs_shacl_ai::deployment::config::ResourceLimits;

// Customize container resources for production
let container_config = ContainerConfig {
    image_tag: "production".to_string(),
    cpu_limit: "1000m".to_string(),
    memory_limit: "2Gi".to_string(),
    ..ContainerConfig::default()
};

// Adjust deployment configuration
let deployment_config = DeploymentConfig {
    environment: EnvironmentType::Production,
    resource_limits: ResourceLimits {
        cpu_limit: 8.0,
        memory_limit_mb: 16384,
        ..ResourceLimits::default()
    },
    ..DeploymentConfig::default()
};

let deployment_manager = DeploymentManager::with_config(deployment_config.clone());

// The deployment manager can now be used to orchestrate deployments
assert_eq!(container_config.image_tag, "production");
assert!(matches!(deployment_config.environment, EnvironmentType::Production));
assert_eq!(deployment_manager.get_statistics().total_deployments, 0);

• Enable caching for repeated validation operations

CPU Optimization

• Lower min_confidence for faster processing with moderate accuracy trade-offs
• Disable reinforcement learning for CPU-constrained environments
• Use parallel processing features for multi-core systems

Quality vs Speed Trade-offs

• High Quality: min_confidence >= 0.9, min_support >= 0.3
• Balanced: min_confidence >= 0.8, min_support >= 0.2 (default)
• High Speed: min_confidence >= 0.7, min_support >= 0.1

Production Deployment Guide

Container Deployment

use oxirs_shacl_ai::{ContainerConfig, DeploymentConfig, DeploymentManager, ShaclAiAssistant};
use oxirs_shacl_ai::deployment::EnvironmentType;

let mut assistant = ShaclAiAssistant::new();
assert!(assistant.config().global.enable_parallel_processing);

// Configure container image and registry settings
let container_config = ContainerConfig {
    image_name: "oxirs-shacl-ai".to_string(),
    image_tag: "stable".to_string(),
    registry: "registry.example.com/oxirs".to_string(),
    ..ContainerConfig::default()
};

// Tailor deployment for staging environment with existing defaults
let deployment_config = DeploymentConfig {
    environment: EnvironmentType::Staging,
    ..DeploymentConfig::default()
};

let deployment_manager = DeploymentManager::with_config(deployment_config.clone());

assert_eq!(container_config.registry, "registry.example.com/oxirs");
assert!(matches!(deployment_config.environment, EnvironmentType::Staging));
assert_eq!(deployment_manager.get_statistics().total_deployments, 0);

Load Balancing and Auto-scaling

use std::time::Duration;
use oxirs_shacl_ai::deployment::config::AutoScalingConfig;
use oxirs_shacl_ai::deployment::load_balancing::{LoadBalancerConfig, LoadBalancerType};
use oxirs_shacl_ai::deployment::orchestration::LoadBalancingAlgorithm;

let load_balancer_config = LoadBalancerConfig {
    balancer_type: LoadBalancerType::ApplicationLoadBalancer,
    algorithm: LoadBalancingAlgorithm::LeastConnections,
    sticky_sessions: true,
    ..LoadBalancerConfig::default()
};

let auto_scaling_config = AutoScalingConfig {
    min_instances: 3,
    max_instances: 12,
    scale_up_threshold: 0.75,
    scale_down_threshold: 0.35,
    scale_up_cooldown: Duration::from_secs(180),
    scale_down_cooldown: Duration::from_secs(300),
    ..AutoScalingConfig::default()
};

assert!(load_balancer_config.sticky_sessions);
assert_eq!(auto_scaling_config.min_instances, 3);

Real-World Use Cases

Enterprise Data Quality Assessment

use oxirs_shacl_ai::ShaclAiAssistant;

// Create the AI assistant
let mut assistant = ShaclAiAssistant::new();

// 1. Learn shapes from existing data
let shapes = assistant.learn_shapes(store, None)?;
println!("Discovered {} data patterns", shapes.len());

// 2. Assess current data quality
let quality_report = assistant.assess_quality(store, &shapes)?;
println!("Overall quality score: {:.2}%", quality_report.overall_score * 100.0);

// 3. Generate improvement recommendations
let insights = assistant.generate_insights(store, &shapes, &[])?;
for recommendation in &insights.recommendations {
    println!("Recommendation: {}", recommendation.description);
}

Streaming Data Validation

use std::time::Duration;
use oxirs_shacl_ai::{
    StreamingAdaptationEngine, StreamingConfig, SelfAdaptiveAI, SelfAdaptiveConfig,
};

let streaming_config = StreamingConfig {
    stream_buffer_size: 500,
    adaptation_threshold: 0.15,
    pattern_recognition_interval: Duration::from_secs(5),
    performance_monitoring_interval: Duration::from_secs(2),
    ..StreamingConfig::default()
};

let adaptive_ai = SelfAdaptiveAI::new(SelfAdaptiveConfig::default());
let streaming_engine = StreamingAdaptationEngine::new(adaptive_ai, streaming_config.clone());

assert_eq!(streaming_engine.config().stream_buffer_size, 500);
assert!(streaming_config.enable_backpressure);

Multi-Modal Content Validation

use oxirs_shacl_ai::{MultiModalValidator, MultiModalConfig, ContentType};

let multimodal_config = MultiModalConfig {
    enable_image_validation: true,
    enable_audio_validation: true,
    enable_video_validation: true,
    enable_text_validation: true,
    enable_document_validation: true,
    quality_threshold: 0.8,
    ..Default::default()
};

let _validator = MultiModalValidator::new(multimodal_config.clone());
assert!(multimodal_config.enable_text_validation);

// Validate different content types
// let image_result = validator.validate_content(ContentType::Image, &image_data)?;
// let text_result = validator.validate_content(ContentType::Text, &text_data)?;

Troubleshooting Guide

Common Issues and Solutions

High Memory Usage

• Reduce max_shapes in LearningConfig
• Increase min_support threshold to filter out rare patterns
• Enable result caching with appropriate size limits
• Use streaming processing for large datasets

Slow Performance

• Enable parallel processing: global.enable_parallel_processing = true
• Reduce min_confidence for faster but less accurate results
• Disable complex features like reinforcement learning for simple use cases
• Use GPU acceleration when available

Low Quality Results

• Increase min_confidence and min_support thresholds
• Enable model training with sufficient training data
• Use ensemble methods in model selection
• Validate training data quality before model training

Training Failures

• Check training data format and completeness
• Verify sufficient training examples (>1000 recommended)
• Adjust learning rates and batch sizes
• Monitor memory usage during training

Performance Monitoring

use oxirs_shacl_ai::SystemMonitor;
use oxirs_shacl_ai::system_monitoring::{AlertThresholds, MonitoringConfig};

let monitoring_config = MonitoringConfig {
    enable_real_time: true,
    enable_performance_tracking: true,
    enable_quality_tracking: true,
    alert_thresholds: AlertThresholds {
        max_response_time_ms: 5000.0,
        max_error_rate: 0.05,
        max_memory_usage_percent: 80.0,
        max_cpu_usage_percent: 85.0,
        min_quality_score: 75.0,
        ..AlertThresholds::default()
    },
    ..MonitoringConfig::default()
};

let monitor = SystemMonitor::with_config(monitoring_config);
// monitor.start_monitoring()?;

API Reference Summary

Core Components

• ShaclAiAssistant: Main entry point for AI-powered SHACL operations
• ShapeLearner: Automated shape discovery and learning
• QualityAssessor: Data quality analysis and reporting
• ValidationPredictor: Validation outcome prediction
• OptimizationEngine: Performance and strategy optimization

Advanced Features

• AiOrchestrator: Comprehensive AI-powered learning pipeline
• QuantumConsciousnessSynthesis: Ultra-advanced consciousness-guided validation
• TemporalParadoxResolution: Multi-timeline validation consistency
• MultiModalValidation: Cross-modal content validation
• StreamingAdaptation: Real-time adaptive validation for streaming data

Configuration Classes

• ShaclAiConfig: Global configuration for all AI operations
• LearningConfig: Shape learning parameters and thresholds
• QualityConfig: Quality assessment settings
• PredictionConfig: Validation prediction configuration
• OptimizationConfig: Performance optimization settings

Re-exports

pub use constraint_synthesizer::ConstraintSynthesizer;

pub use constraint_synthesizer::ConstraintType;

pub use constraint_synthesizer::DataSample;

pub use constraint_synthesizer::SynthesizedConstraint;

pub use ab_testing::ABTestConfig;

pub use ab_testing::ABTestFramework;

pub use ab_testing::Experiment as ABExperiment;

pub use ab_testing::ExperimentResults;

pub use ab_testing::ExperimentStatus as ABExperimentStatus;

pub use ab_testing::MetricDefinition;

pub use ab_testing::MetricGoal;

pub use ab_testing::MetricSummary;

pub use ab_testing::MetricType as ABMetricType;

pub use ab_testing::Recommendation;

pub use ab_testing::RecommendationAction;

pub use ab_testing::StatisticalTest;

pub use ab_testing::StatisticalTestType;

pub use ab_testing::Variant;

pub use advanced_features::ActiveLearner;

pub use advanced_features::ActiveLearningConfig;

pub use advanced_features::AdvancedAnomalyDetector;

pub use advanced_features::AnomalyDetectionConfig;

pub use advanced_features::CollectiveAnomalyDetector;

pub use advanced_features::ContextualAnomalyDetector;

pub use advanced_features::ContinualLearner;

pub use advanced_features::ContinualLearningConfig;

pub use advanced_features::DomainAdapter;

pub use advanced_features::EnsembleLearner;

pub use advanced_features::EnsembleStrategy as AdvancedEnsembleStrategy;

pub use advanced_features::GanModel;

pub use advanced_features::GenerativeModel;

pub use advanced_features::GnnLayer;

pub use advanced_features::GnnLayerType;

pub use advanced_features::GraphConvolution;

pub use advanced_features::GraphNeuralNetwork;

pub use advanced_features::GraphNeuralNetworkConfig;

pub use advanced_features::MemoryBuffer;

pub use advanced_features::MessagePassingConfig;

pub use advanced_features::ModelEnsemble;

pub use advanced_features::NoveltyDetector;

pub use advanced_features::PlasticityPreservation;

pub use advanced_features::PretrainedModel;

pub use advanced_features::QueryStrategy;

pub use advanced_features::SamplingStrategy;

pub use advanced_features::ShapeEmbedding;

pub use advanced_features::TestDataGenerator;

pub use advanced_features::TransferLearner;

pub use advanced_features::TransferLearningConfig;

pub use advanced_features::TransferStrategy;

pub use advanced_features::UncertaintySampling;

pub use advanced_features::VariationalAutoencoder;

pub use advanced_features::VotingStrategy;

pub use advanced_features::WeightedEnsemble;

pub use advanced_neural::AdvancedNeuralArchitecture;

pub use advanced_neural::AdvancedNeuralManager;

pub use advanced_neural::ArchitectureConfig;

pub use advanced_neural::ArchitectureType;

pub use advanced_neural::EarlyStoppingConfig;

pub use advanced_neural::ManagerConfig;

pub use advanced_neural::ODESolverType;

pub use advanced_neural::OptimizerType;

pub use advanced_neural::PerformanceMetrics as NeuralPerformanceMetrics;

pub use advanced_neural::RegularizationConfig;

pub use advanced_neural::TrainingData;

pub use advanced_neural::TrainingState;

pub use advanced_pattern_mining::AdvancedPattern;

pub use advanced_pattern_mining::AdvancedPatternMiningConfig;

pub use advanced_pattern_mining::AdvancedPatternMiningEngine;

pub use advanced_pattern_mining::ConstraintType as MiningConstraintType;

pub use advanced_pattern_mining::ItemRole;

pub use advanced_pattern_mining::PatternItem;

pub use advanced_pattern_mining::PatternItemType;

pub use advanced_pattern_mining::PatternMiningStats;

pub use advanced_pattern_mining::PatternType as MiningPatternType;

pub use advanced_pattern_mining::SeasonalityComponent;

pub use advanced_pattern_mining::SuggestedConstraint;

pub use advanced_pattern_mining::TemporalPatternInfo;

pub use advanced_pattern_mining::TrendDirection as MiningTrendDirection;

pub use advanced_scirs2_integration::AdvancedSciRS2Config;

pub use advanced_scirs2_integration::AdvancedSciRS2Engine;

pub use advanced_scirs2_integration::BenchmarkResults;

pub use advanced_scirs2_integration::CloudProviderType;

pub use advanced_validation_strategies::AdvancedValidationConfig;

pub use advanced_validation_strategies::AdvancedValidationResult;

pub use advanced_validation_strategies::AdvancedValidationStrategyManager;

pub use advanced_validation_strategies::ComputationalComplexity;

pub use advanced_validation_strategies::ContextAwarenessLevel;

pub use advanced_validation_strategies::DataCharacteristics;

pub use advanced_validation_strategies::DomainContext;

pub use advanced_validation_strategies::DomainType;

pub use advanced_validation_strategies::PerformanceRequirements as ValidationPerformanceRequirements;

pub use advanced_validation_strategies::PriorityLevel;

pub use advanced_validation_strategies::QualityMetrics;

pub use advanced_validation_strategies::QualityRequirements;

pub use advanced_validation_strategies::ShapeCharacteristics;

pub use advanced_validation_strategies::StrategyCapabilities;

pub use advanced_validation_strategies::StrategySelectionApproach;

pub use advanced_validation_strategies::StrategyValidationResult;

pub use advanced_validation_strategies::UncertaintyMetrics;

pub use advanced_validation_strategies::UncertaintySource;

pub use advanced_validation_strategies::UncertaintySourceType;

pub use advanced_validation_strategies::ValidationContext;

pub use advanced_validation_strategies::ValidationExplanation;

pub use advanced_validation_strategies::ValidationStrategy;

pub use advanced_visualization::AdvancedVisualizationEngine;

pub use advanced_visualization::ArchitectureVisualizationType;

pub use advanced_visualization::ColorScheme;

pub use advanced_visualization::ExportFormat;

pub use advanced_visualization::ExportResult;

pub use advanced_visualization::InteractiveControls;

pub use advanced_visualization::QuantumVisualizationMode;

pub use advanced_visualization::VisualizationConfig;

pub use advanced_visualization::VisualizationData;

pub use advanced_visualization::VisualizationOutput;

pub use ai_orchestrator::AdaptiveLearningInsights;

pub use ai_orchestrator::AdvancedModelSelector;

pub use ai_orchestrator::AiOrchestrator;

pub use ai_orchestrator::AiOrchestratorConfig;

pub use ai_orchestrator::AiOrchestratorStats;

pub use ai_orchestrator::ComprehensiveLearningResult;

pub use ai_orchestrator::ConfidenceDistribution;

pub use ai_orchestrator::ConfidentShape;

pub use ai_orchestrator::DataCharacteristics as OrchestratorDataCharacteristics;

pub use ai_orchestrator::LearningMetadata;

pub use ai_orchestrator::ModelPerformanceMetrics;

pub use ai_orchestrator::ModelSelectionResult;

pub use ai_orchestrator::ModelSelectionStats;

pub use ai_orchestrator::ModelSelectionStrategy as AiModelSelectionStrategy;

pub use ai_orchestrator::OptimizationRecommendation as OrchestratorOptimizationRecommendation;

pub use ai_orchestrator::OrchestrationMetrics;

pub use ai_orchestrator::PerformanceRequirements as AiPerformanceRequirements;

pub use ai_orchestrator::PredictiveInsights;

pub use ai_orchestrator::QualityAnalysis;

pub use ai_orchestrator::SelectedModel;

pub use anomaly_detection::AdvancedAnomalyExplainer;

pub use anomaly_detection::AdvancedExplanationReport;

pub use anomaly_detection::Anomaly;

pub use anomaly_detection::AnomalyConfig;

pub use anomaly_detection::AnomalyDetector;

pub use anomaly_detection::AnomalyExplainer;

pub use anomaly_detection::AnomalyScore;

pub use anomaly_detection::AnomalyType;

pub use anomaly_detection::ConfidenceBreakdown;

pub use anomaly_detection::DataDistribution as AnomalyDataDistribution;

pub use anomaly_detection::DetailedExplanation;

pub use anomaly_detection::DetectionMetrics;

pub use anomaly_detection::DetectorResult;

pub use anomaly_detection::DetectorType;

pub use anomaly_detection::DriftDetector;

pub use anomaly_detection::DriftResult;

pub use anomaly_detection::DriftType;

pub use anomaly_detection::EnsembleConfig;

pub use anomaly_detection::EnsembleDetector;

pub use anomaly_detection::EnsembleResult;

pub use anomaly_detection::ExplainerConfig;

pub use anomaly_detection::ExplainerPriority;

pub use anomaly_detection::ExplanationDetailLevel;

pub use anomaly_detection::ExplanationReport;

pub use anomaly_detection::ExplanationTechnique;

pub use anomaly_detection::NoveltyDetector as ExistingNoveltyDetector;

pub use anomaly_detection::NoveltyResult;

pub use anomaly_detection::OutlierDetector;

pub use anomaly_detection::OutlierMethod;

pub use anomaly_detection::OutlierResult;

pub use anomaly_detection::RdfAnomaly;

pub use anomaly_detection::RemediationSuggestion;

pub use anomaly_detection::VisualizationData as AnomalyVisualizationData;

pub use bias_detection::AttributeType;

pub use bias_detection::BiasData;

pub use bias_detection::BiasDetectionConfig;

pub use bias_detection::BiasDetectionResult;

pub use bias_detection::BiasDetector;

pub use bias_detection::BiasMetric;

pub use bias_detection::BiasMetricType;

pub use bias_detection::BiasSeverity;

pub use bias_detection::CausalPathway;

pub use bias_detection::DetectedBias;

pub use bias_detection::FairnessTracker;

pub use bias_detection::FairnessTrend;

pub use bias_detection::GroupMetrics;

pub use bias_detection::InProcessingMethod;

pub use bias_detection::IntersectionGroup;

pub use bias_detection::IntersectionalAnalysis;

pub use bias_detection::LegalProtectionLevel;

pub use bias_detection::MitigationResult;

pub use bias_detection::MitigationStrategy;

pub use bias_detection::MitigationType;

pub use bias_detection::PostprocessingMethod;

pub use bias_detection::PreprocessingMethod;

pub use bias_detection::ProtectedAttribute;

pub use constraint_generation::CardinalityAnalyzer;

pub use constraint_generation::CardinalityConstraint;

pub use constraint_generation::ConstraintGenerationConfig;

pub use constraint_generation::ConstraintGenerator;

pub use constraint_generation::ConstraintRanker;

pub use constraint_generation::ConstraintSuggestion;

pub use constraint_generation::ConstraintTrainingExample;

pub use constraint_generation::ConstraintValidator;

pub use constraint_generation::DatatypeAnalyzer;

pub use constraint_generation::DatatypeConstraint;

pub use constraint_generation::FineTuningResult;

pub use constraint_generation::GeneratedConstraint;

pub use constraint_generation::GenerationResult;

pub use constraint_generation::PatternBasedGenerator;

pub use constraint_generation::PatternConstraint;

pub use constraint_generation::PatternType as ConstraintPatternType;

pub use constraint_generation::RankedConstraint;

pub use constraint_generation::RankingCriteria;

pub use constraint_generation::RdfPattern;

pub use constraint_generation::SuggestionConfidence;

pub use constraint_generation::SuggestionEngine;

pub use constraint_generation::TransformerConstraintConfig;

pub use constraint_generation::TransformerConstraintGenerator;

pub use constraint_generation::TransformerConstraintStats;

pub use constraint_generation::ValidationResult as ConstraintValidationResult;

pub use constraint_generation::ValueRangeAnalyzer;

pub use constraint_generation::ValueRangeConstraint;

pub use edge_deployment::ActiveDeployment;

pub use edge_deployment::DeploymentPackage;

pub use edge_deployment::DeploymentPerformance;

pub use edge_deployment::DeploymentStatus;

pub use edge_deployment::DevicePlatform;

pub use edge_deployment::DeviceProfile;

pub use edge_deployment::EdgeDeploymentConfig;

pub use edge_deployment::EdgeDeploymentError;

pub use edge_deployment::EdgeDeploymentManager;

pub use edge_deployment::EdgeDevice;

pub use edge_deployment::OptimizationResult as EdgeOptimizationResult;

pub use edge_deployment::ResourceUsage;

pub use ensemble::EdgeFeature;

pub use ensemble::EnsembleStrategy as ShapeEnsembleStrategy;

pub use ensemble::GraphFeatures;

pub use ensemble::GraphStats;

pub use ensemble::NodeFeature;

pub use ensemble::ShapeLearnerEnsemble;

pub use ensemble::ShapePrediction;

pub use ensemble::TrainingExample;

pub use ensemble::TrainingMetrics;

pub use error_handling::ErrorClassificationResult;

pub use error_handling::ErrorHandlingConfig;

pub use error_handling::ErrorSeverity;

pub use error_handling::ErrorType;

pub use error_handling::IntelligentErrorHandler;

pub use error_handling::RepairSuggestion;

pub use error_handling::RepairType;

pub use error_handling::SmartErrorAnalysis;

pub use hyperparameter_optimization::HpoStrategy;

pub use hyperparameter_optimization::HyperparameterOptimizer;

pub use hyperparameter_optimization::OptimizationConfig;

pub use hyperparameter_optimization::OptimizationResult as HpoOptimizationResult;

pub use hyperparameter_optimization::OptimizationTrial;

pub use hyperparameter_optimization::OptimizerStats;

pub use hyperparameter_optimization::ParameterSpace;

pub use hyperparameter_optimization::SearchSpace;

pub use hyperparameter_optimization::TrialStatus;

pub use inference::quantize_model;

pub use inference::Activation;

pub use inference::BatchedInferenceConfig;

pub use inference::BatchedInferenceEngine;

pub use inference::CalibrationCollector;

pub use inference::FusedLinearKernel;

pub use inference::InferenceEngineStats;

pub use inference::InferencePipelineConfig;

pub use inference::InferenceRequest;

pub use inference::InferenceResult;

pub use inference::PipelineStats;

pub use inference::PredictedViolation;

pub use inference::QuantizationConfig as InferenceQuantizationConfig;

pub use inference::QuantizationParams;

pub use inference::QuantizationSummary;

pub use inference::QuantizedInferenceResult;

pub use inference::QuantizedWeightMatrix;

pub use inference::RealTimeInferencePipeline;

pub use integration_testing::DataConfiguration;

pub use integration_testing::DependencyAnalysisResult;

pub use integration_testing::ErrorDetails;

pub use integration_testing::ExecutionMetadata;

pub use integration_testing::IntegrationTestConfig;

pub use integration_testing::IntegrationTestFramework;

pub use integration_testing::IntegrationTestReport;

pub use integration_testing::LatencyPercentiles;

pub use integration_testing::PerformanceTestMetrics;

pub use integration_testing::QualityMetrics as IntegrationQualityMetrics;

pub use integration_testing::QualityThresholds;

pub use integration_testing::RecommendationPriority;

pub use integration_testing::RecommendationType;

pub use integration_testing::ResourceUtilization;

pub use integration_testing::ScalabilityMetrics;

pub use integration_testing::TestComplexityLevel;

pub use integration_testing::TestRecommendation;

pub use integration_testing::TestResult;

pub use integration_testing::TestStatus;

pub use integration_testing::TestSummary;

pub use integration_testing::TestType;

pub use integration_testing::ValidationTestResults;

pub use interactive_labeling::Annotation;

pub use interactive_labeling::AnnotationTask;

pub use interactive_labeling::Annotator;

pub use interactive_labeling::AnnotatorStats;

pub use interactive_labeling::InteractiveLabelingInterface;

pub use interactive_labeling::LabelingConfig;

pub use interactive_labeling::PriorityStrategy;

pub use interactive_labeling::QualityMetrics as LabelingQualityMetrics;

pub use interactive_labeling::RdfData as LabelingRdfData;

pub use interactive_labeling::TaskStatistics;

pub use interactive_labeling::TaskStatus;

pub use knowledge_distillation::AggregationMethod;

pub use knowledge_distillation::CompressionMetrics;

pub use knowledge_distillation::DistillationConfig;

pub use knowledge_distillation::DistillationPerformanceTracker;

pub use knowledge_distillation::DistillationResult;

pub use knowledge_distillation::DistillationStrategy;

pub use knowledge_distillation::DistillationTrainingData;

pub use knowledge_distillation::KnowledgeDistiller;

pub use knowledge_distillation::KnowledgeTransferAnalysis;

pub use knowledge_distillation::ModelArchitecture as DistillationModelArchitecture;

pub use knowledge_distillation::StudentModel;

pub use knowledge_distillation::TeacherModel;

pub use knowledge_distillation::TrainingHistory as DistillationTrainingHistory;

pub use learning::LearningConfig;

pub use learning::LearningPerformanceMetrics;

pub use learning::LearningStatistics;

pub use learning::PatternStatistics;

pub use learning::ShapeExample;

pub use learning::ShapeLearner;

pub use learning::ShapeTrainingData as LearningTrainingData;

pub use learning::TemporalPatterns;

pub use llm::BatchGenerationRequest;

pub use llm::BatchItemResult;

pub use llm::GeneratedShaclShape;

pub use llm::GeneratorStats;

pub use llm::LlmConstraintGenerator;

pub use llm::LlmConstraintGeneratorConfig;

pub use llm::LlmProvider;

pub use llm::LlmRequest;

pub use llm::LlmResponse;

pub use llm::PromptTemplate;

pub use llm::StubLlmProvider;

pub use llm::TokenUsage;

pub use meta_learning::AdaptationStrategy;

pub use meta_learning::AdaptedModel;

pub use meta_learning::LearningTask;

pub use meta_learning::MetaLearner;

pub use meta_learning::MetaLearningConfig;

pub use meta_learning::MetaLearningResult;

pub use meta_learning::TaskType;

pub use ml::LearnedConstraint;

pub use ml::LearnedShape;

pub use ml::ModelError;

pub use ml::ModelMetrics;

pub use ml::ModelParams;

pub use ml::ShapeLearningModel;

pub use ml::ShapeTrainingData as MlTrainingData;

pub use model_compression::CalibrationData;

pub use model_compression::CompressionConfig;

pub use model_compression::CompressionMethod;

pub use model_compression::CompressionResult;

pub use model_compression::CompressionStrategy;

pub use model_compression::CompressionTracker;

pub use model_compression::CompressionValidationData;

pub use model_compression::DetailedCompressionMetrics;

pub use model_compression::ModelCompressor;

pub use model_compression::PrunedModel;

pub use model_compression::PruningConfig;

pub use model_compression::PruningSchedule;

pub use model_compression::PruningType;

pub use model_compression::QuantizationConfig;

pub use model_compression::QuantizationScheme;

pub use model_compression::QuantizationType;

pub use model_compression::QuantizedModel;

pub use model_compression::QuantizedTensor;

pub use model_drift_monitoring::AlertSeverity;

pub use model_drift_monitoring::AlertStatus;

pub use model_drift_monitoring::DataStatistics;

pub use model_drift_monitoring::DriftAlert;

pub use model_drift_monitoring::DriftMeasurement;

pub use model_drift_monitoring::DriftMonitor;

pub use model_drift_monitoring::DriftMonitorConfig;

pub use model_drift_monitoring::DriftReport;

pub use model_drift_monitoring::ModelDriftType;

pub use model_drift_monitoring::MonitoringStats;

pub use model_governance::Approval;

pub use model_governance::ApprovalStatus;

pub use model_governance::AuditEntry;

pub use model_governance::ComplianceCheck;

pub use model_governance::ComplianceResult;

pub use model_governance::ComplianceStandard;

pub use model_governance::GovernanceError;

pub use model_governance::GovernanceMetrics;

pub use model_governance::GovernancePolicy;

pub use model_governance::ModelGovernance;

pub use model_governance::ModelGovernanceConfig;

pub use model_governance::ModelGovernanceMetadata;

pub use model_governance::ModelLifecycleStage;

pub use model_governance::PolicyRule;

pub use model_governance::PolicyType;

pub use model_governance::RiskAssessment;

pub use model_governance::RiskFactor;

pub use model_governance::RiskLevel as GovernanceRiskLevel;

pub use model_governance::Violation;

pub use model_governance::ViolationSeverity;

pub use model_registry::ModelComparison;

pub use model_registry::ModelMetadata;

pub use model_registry::ModelParameters;

pub use model_registry::ModelRegistrationBuilder;

pub use model_registry::ModelRegistry;

pub use model_registry::ModelStatus;

pub use model_registry::ModelType;

pub use model_registry::PerformanceMetrics as RegistryPerformanceMetrics;

pub use model_registry::RegisteredModel;

pub use model_registry::RegistryConfig;

pub use model_registry::TrainingMetrics as RegistryTrainingMetrics;

pub use model_registry::Version;

pub use models::AttributedGraph;

pub use models::ConstraintHead;

pub use models::FeatureEncoder;

pub use models::FeedForward;

pub use models::GraphEdge;

pub use models::GraphNode;

pub use models::GraphTransformerConfig;

pub use models::GraphTransformerLayer;

pub use models::GtShaclModel;

pub use models::GtShaclStats;

pub use models::GtShaclTrainer;

pub use models::LayerNorm;

pub use models::LearnedRule;

pub use models::Linear;

pub use models::MultiHeadAttention as ModelMultiHeadAttention;

pub use models::RuleBasedShapeLearner;

pub use models::TrainingReport;

pub use multi_task_learning::ActivationType;

pub use multi_task_learning::ConvergenceInfo;

pub use multi_task_learning::GradientNormalizer;

pub use multi_task_learning::LayerNormalization;

pub use multi_task_learning::LearnedTaskModel;

pub use multi_task_learning::LearningObjective as MultiTaskLearningObjective;

pub use multi_task_learning::MultiTaskConfig;

pub use multi_task_learning::MultiTaskLearner;

pub use multi_task_learning::MultiTaskLearningResult;

pub use multi_task_learning::MultiTaskMetrics;

pub use multi_task_learning::MultiTaskPerformanceTracker;

pub use multi_task_learning::NormalizationMethod;

pub use multi_task_learning::RelationshipType as TaskRelationshipType;

pub use multi_task_learning::SharedEncoder;

pub use multi_task_learning::SharedLayer;

pub use multi_task_learning::SharingType;

pub use multi_task_learning::Task as MultiTask;

pub use multi_task_learning::TaskGradients;

pub use multi_task_learning::TaskHead;

pub use multi_task_learning::TaskLayer;

pub use multi_task_learning::TaskPerformance;

pub use multi_task_learning::TaskRelationship;

pub use multi_task_learning::TaskRelationshipGraph;

pub use multi_task_learning::TaskResult;

pub use multi_task_learning::TaskTrainingData;

pub use multi_task_learning::TaskType as MultiTaskType;

pub use multi_task_learning::TransferDirection;

pub use neural_cost_estimation::ContextAwareCostAdjuster;

pub use neural_cost_estimation::DeepCostPredictor;

pub use neural_cost_estimation::EnsembleCostPredictor;

pub use neural_cost_estimation::FeatureExtractionConfig;

pub use neural_cost_estimation::HistoricalDataConfig;

pub use neural_cost_estimation::HistoricalDataManager;

pub use neural_cost_estimation::MultiDimensionalFeatureExtractor;

pub use neural_cost_estimation::NetworkArchitecture;

pub use neural_cost_estimation::NeuralCostEstimationConfig;

pub use neural_cost_estimation::NeuralCostEstimationEngine;

pub use neural_cost_estimation::NeuralCostEstimationStats;

pub use neural_cost_estimation::PerformanceProfiler;

pub use neural_cost_estimation::RealTimeFeedbackProcessor;

pub use neural_cost_estimation::UncertaintyQuantifier;

pub use neural_patterns::attention::AttentionHead;

pub use neural_patterns::AdvancedPatternCorrelationAnalyzer;

pub use neural_patterns::AnalysisQualityMetrics;

pub use neural_patterns::AttentionFlowDynamics;

pub use neural_patterns::AttentionHotspot;

pub use neural_patterns::AttentionInsights;

pub use neural_patterns::AttentionPathway;

pub use neural_patterns::CausalMechanism;

pub use neural_patterns::CausalRelationship;

pub use neural_patterns::CentralityScores;

pub use neural_patterns::ClusterCharacteristics;

pub use neural_patterns::CorrelationAnalysisConfig;

pub use neural_patterns::CorrelationAnalysisMetadata;

pub use neural_patterns::CorrelationAnalysisResult;

pub use neural_patterns::CorrelationAnalysisStats;

pub use neural_patterns::CorrelationCluster;

pub use neural_patterns::CorrelationEvidence;

pub use neural_patterns::CorrelationType;

pub use neural_patterns::CrossPatternAttention;

pub use neural_patterns::CrossScaleInteraction;

pub use neural_patterns::EmergencePattern;

pub use neural_patterns::GraphStatistics;

pub use neural_patterns::HierarchyLevel;

pub use neural_patterns::HierarchyMetrics;

pub use neural_patterns::HotspotType;

pub use neural_patterns::InteractionType;

pub use neural_patterns::LearnedConstraintPattern;

pub use neural_patterns::MechanismType;

pub use neural_patterns::MultiScaleFinding;

pub use neural_patterns::NeuralPattern;

pub use neural_patterns::NeuralPatternConfig;

pub use neural_patterns::NeuralPatternRecognizer;

pub use neural_patterns::PatternCorrelation;

pub use neural_patterns::PatternHierarchy;

pub use neural_patterns::PatternNode;

pub use neural_patterns::PatternRelationshipGraph;

pub use neural_patterns::RelationshipEdge;

pub use neural_patterns::TemporalBehavior;

pub use neural_patterns::TemporalDynamics;

pub use neural_patterns::TrendDirection as NeuralTrendDirection;

pub use neural_transformer_pattern_integration::AttentionCostPredictor;

pub use neural_transformer_pattern_integration::MultiHeadAttention;

pub use neural_transformer_pattern_integration::NeuralTransformerConfig;

pub use neural_transformer_pattern_integration::NeuralTransformerPatternIntegration;

pub use neural_transformer_pattern_integration::NeuralTransformerStats;

pub use neural_transformer_pattern_integration::PatternEmbedder;

pub use neural_transformer_pattern_integration::PatternMemoryBank;

pub use neural_transformer_pattern_integration::PatternMemoryEntry;

pub use neural_transformer_pattern_integration::PositionalEncoder;

pub use neural_transformer_pattern_integration::TransformerEncoder;

pub use neural_transformer_pattern_integration::TransformerEncoderLayer;

pub use optimization_engine::AdaptiveOptimizer;

pub use optimization_engine::AdvancedOptimizationEngine;

pub use optimization_engine::AntColonyOptimizer;

pub use optimization_engine::BayesianOptimizer;

pub use optimization_engine::CacheConfiguration;

pub use optimization_engine::DifferentialEvolutionOptimizer;

pub use optimization_engine::GeneticOptimizer;

pub use optimization_engine::MultiObjectiveOptimizer;

pub use optimization_engine::OptimizationConfig as AdvancedOptimizationConfig;

pub use optimization_engine::OptimizationResult;

pub use optimization_engine::OptimizedShape;

pub use optimization_engine::ParallelValidationConfig;

pub use optimization_engine::ParticleSwarmOptimizer;

pub use optimization_engine::PerformanceMetrics as OptimizationPerformanceMetrics;

pub use optimization_engine::ReinforcementLearningOptimizer;

pub use optimization_engine::SimulatedAnnealingOptimizer;

pub use optimization_engine::TabuSearchOptimizer;

pub use performance_benchmarking::AccessPattern;

pub use performance_benchmarking::BenchmarkConfig;

pub use performance_benchmarking::BenchmarkResult;

pub use performance_benchmarking::BenchmarkStatus;

pub use performance_benchmarking::BenchmarkType;

pub use performance_benchmarking::CacheBehavior;

pub use performance_benchmarking::DataDistribution;

pub use performance_benchmarking::ExecutionSummary as BenchmarkSummary;

pub use performance_benchmarking::MeasurementConfig;

pub use performance_benchmarking::PerformanceBenchmarkFramework;

pub use performance_benchmarking::PrecisionLevel;

pub use performance_benchmarking::ResourceUsageSummary as ResourceMetrics;

pub use performance_benchmarking::SuccessCriteria;

pub use performance_benchmarking::TargetComponent;

pub use performance_benchmarking::ThroughputSummary as ThroughputMetrics;

pub use performance_benchmarking::WorkloadConfig;

pub use production_monitoring::Alert;

pub use production_monitoring::AlertChannel;

pub use production_monitoring::AlertSeverity as ProdAlertSeverity;

pub use production_monitoring::AlertType;

pub use production_monitoring::DataQualityMetrics;

pub use production_monitoring::MonitoringConfig;

pub use production_monitoring::MonitoringError;

pub use production_monitoring::PerformanceMetrics as ProdPerformanceMetrics;

pub use production_monitoring::PredictionMetrics;

pub use production_monitoring::ProductionMonitor;

pub use production_monitoring::SLA;

pub use realtime_adaptive_query_optimizer::AdaptationRecommendation;

pub use realtime_adaptive_query_optimizer::AdaptiveOptimizerConfig;

pub use realtime_adaptive_query_optimizer::AdaptiveOptimizerStats;

pub use realtime_adaptive_query_optimizer::AdaptivePlanCache;

pub use realtime_adaptive_query_optimizer::CacheStatistics;

pub use realtime_adaptive_query_optimizer::ComplexityAnalysis;

pub use realtime_adaptive_query_optimizer::ComplexityFactor;

pub use realtime_adaptive_query_optimizer::ExecutionMetrics;

pub use realtime_adaptive_query_optimizer::FeedbackProcessor;

pub use realtime_adaptive_query_optimizer::MLPlanSelector;

pub use realtime_adaptive_query_optimizer::OnlineLearningEngine;

pub use realtime_adaptive_query_optimizer::OnlineLearningStats;

pub use realtime_adaptive_query_optimizer::OptimizationPlanType;

pub use realtime_adaptive_query_optimizer::OptimizationRecommendation as RealtimeOptimizationRecommendation;

pub use realtime_adaptive_query_optimizer::PerformanceMetrics as RealtimePerformanceMetrics;

pub use realtime_adaptive_query_optimizer::PerformanceMonitor;

pub use realtime_adaptive_query_optimizer::QueryComplexityAnalyzer;

pub use realtime_adaptive_query_optimizer::QueryPerformanceRecord;

pub use realtime_adaptive_query_optimizer::RealTimeAdaptiveQueryOptimizer;

pub use realtime_adaptive_query_optimizer::TrendDirection as RealtimeTrendDirection;

pub use realtime_anomaly_streams::AdaptiveThreshold;

pub use realtime_anomaly_streams::AdaptiveThresholdManager;

pub use realtime_anomaly_streams::AlertManager;

pub use realtime_anomaly_streams::AlertSeverity as StreamAlertSeverity;

pub use realtime_anomaly_streams::AlertSuppressionRule;

pub use realtime_anomaly_streams::AnomalyStreamProcessor;

pub use realtime_anomaly_streams::DetectedStreamAnomaly;

pub use realtime_anomaly_streams::EscalationPolicy;

pub use realtime_anomaly_streams::NotificationChannel;

pub use realtime_anomaly_streams::SlidingWindow;

pub use realtime_anomaly_streams::StreamAlert;

pub use realtime_anomaly_streams::StreamConfig;

pub use realtime_anomaly_streams::StreamDataPoint;

pub use realtime_anomaly_streams::StreamPerformanceTracker;

pub use realtime_anomaly_streams::StreamProcessingResult;

pub use realtime_anomaly_streams::StreamingDetectionModel;

pub use realtime_anomaly_streams::StreamingModelType;

pub use realtime_anomaly_streams::ThresholdAdaptation;

pub use realtime_anomaly_streams::WindowStatistics;

pub use sophisticated_validation_optimization::ConstraintSatisfactionStrategy;

pub use sophisticated_validation_optimization::EnvironmentalFactors;

pub use sophisticated_validation_optimization::OptimizationContext;

pub use sophisticated_validation_optimization::OptimizationMetrics;

pub use sophisticated_validation_optimization::OptimizationObjective;

pub use sophisticated_validation_optimization::OptimizationParameters;

pub use sophisticated_validation_optimization::OptimizationPriority;

pub use sophisticated_validation_optimization::OptimizationRecommendation;

pub use sophisticated_validation_optimization::OptimizationRecommendationType;

pub use sophisticated_validation_optimization::OptimizationResult as SophisticatedOptimizationResult;

pub use sophisticated_validation_optimization::OptimizationSolution;

pub use sophisticated_validation_optimization::OptimizationStepType;

pub use sophisticated_validation_optimization::OptimizationStrategy;

pub use sophisticated_validation_optimization::ParetoSolution;

pub use sophisticated_validation_optimization::RiskLevel;

pub use sophisticated_validation_optimization::SophisticatedOptimizationConfig;

pub use sophisticated_validation_optimization::SophisticatedValidationOptimizer;

pub use training::dequantise_gradients_i8;

pub use training::finite_difference_grad;

pub use training::quantise_gradients_i8;

pub use training::sparsify_gradients;

pub use training::AdamOptimiser;

pub use training::AllReduceStrategy;

pub use training::AllReduceSync;

pub use training::DistributedTrainer;

pub use training::DistributedTrainingConfig;

pub use training::DistributedTrainingStats;

pub use training::GradientAccumulator;

pub use training::ParameterVector;

pub use training::SgdOptimiser;

pub use training::WorkerConfig;

pub use shape_learning::AiValidationReport;

pub use shape_learning::ConstraintLearner;

pub use shape_learning::ConstraintLearningReport;

pub use shape_learning::ConstraintLearningStats;

pub use shape_learning::ConstraintValidationScore;

pub use shape_learning::DetectedPattern;

pub use shape_learning::GraphPattern;

pub use shape_learning::LearnedConstraintResult;

pub use shape_learning::MinedShape;

pub use shape_learning::NodeKind as ShapeMinerNodeKind;

pub use shape_learning::PatternDetectionConfig;

pub use shape_learning::PatternDetectionReport;

pub use shape_learning::PatternDetector;

pub use shape_learning::PatternKind;

pub use shape_learning::ShapeMiner;

pub use shape_learning::ShapeMinerConfig;

pub use shape_learning::ShapeMiningReport;

pub use shape_learning::ShapeMiningStats;

pub use shape_learning::ShapeValidatorAi;

pub use shape_learning::ShapeValidatorAiConfig;

pub use shape_learning::ValidationFinding;

pub use shape_learning::ValidationFindingKind;

pub use blockchain_validation::BlockchainEvent;

pub use blockchain_validation::BlockchainValidationConfig;

pub use blockchain_validation::BlockchainValidationResult;

pub use blockchain_validation::BlockchainValidator;

pub use blockchain_validation::CrossChainAggregation;

pub use blockchain_validation::CrossChainValidationResult;

pub use blockchain_validation::PrivacyLevel;

pub use blockchain_validation::PrivateValidationResult;

pub use blockchain_validation::SmartContractValidationResult;

pub use blockchain_validation::ValidationMode;

pub use crosslingual_transfer::CrosslingualConfig;

pub use crosslingual_transfer::CrosslingualShapeTransfer;

pub use crosslingual_transfer::CrosslingualStats;

pub use crosslingual_transfer::Language;

pub use crosslingual_transfer::TranslatedShape;

pub use crosslingual_transfer::TranslationQuality;

pub use experiment_tracking::Experiment;

pub use experiment_tracking::ExperimentConfig;

pub use experiment_tracking::ExperimentMetrics;

pub use experiment_tracking::ExperimentRun;

pub use experiment_tracking::ExperimentStatus;

pub use experiment_tracking::ExperimentTracker;

pub use experiment_tracking::Metric;

pub use experiment_tracking::MetricType;

pub use experiment_tracking::Parameter;

pub use experiment_tracking::ParameterType;

pub use explainable_ai::AdaptationExplanation;

pub use explainable_ai::AuditTrail;

pub use explainable_ai::DecisionTree;

pub use explainable_ai::DecisionType;

pub use explainable_ai::ExplainableAI;

pub use explainable_ai::ExplainableAIConfig;

pub use explainable_ai::ExplanationDepth;

pub use explainable_ai::FeatureImportanceAnalysis;

pub use explainable_ai::InterpretabilityReport;

pub use explainable_ai::KeyFactor;

pub use explainable_ai::PatternExplanation;

pub use explainable_ai::QuantumExplanation;

pub use explainable_ai::ValidationExplanation as ExplainableValidationExplanation;

pub use feature_store::FeatureGroup;

pub use feature_store::FeatureLineage;

pub use feature_store::FeatureMetadata;

pub use feature_store::FeatureQuery;

pub use feature_store::FeatureStatistics;

pub use feature_store::FeatureStore;

pub use feature_store::FeatureStoreConfig;

pub use feature_store::FeatureStoreError;

pub use feature_store::FeatureStoreMetrics;

pub use feature_store::FeatureType;

pub use feature_store::FeatureValue;

pub use federated_learning::AggregationStrategy;

pub use federated_learning::ConsensusAlgorithm;

pub use federated_learning::FederatedLearningCoordinator;

pub use federated_learning::FederatedNode;

pub use federated_learning::FederationStats;

pub use federated_learning::PrivacyLevel as FederatedPrivacyLevel;

pub use multimodal_validation::ContentType;

pub use multimodal_validation::MultiModalConfig;

pub use multimodal_validation::MultiModalValidationReport;

pub use multimodal_validation::MultiModalValidator;

pub use multimodal_validation::ValidationResult;

pub use neuromorphic_validation::NeuromorphicValidationNetwork;

pub use neuromorphic_validation::NeuromorphicValidationResult;

pub use neuromorphic_validation::NeuronState;

pub use neuromorphic_validation::NeuronType;

pub use neuromorphic_validation::SpikeEvent;

pub use neuromorphic_validation::SpikeStatistics;

pub use neuromorphic_validation::ValidationDecision;

pub use neuromorphic_validation::ValidationNeuron;

pub use streaming_adaptation::AdaptationEvent;

pub use streaming_adaptation::AdaptationEventType;

pub use streaming_adaptation::RealTimeAdaptationStats;

pub use streaming_adaptation::RealTimeMetrics;

pub use streaming_adaptation::StreamType;

pub use streaming_adaptation::StreamingAdaptationEngine;

pub use streaming_adaptation::StreamingConfig;

pub use biological_neural_integration::BiologicalInitResult;

pub use biological_neural_integration::BiologicalIntegrationConfig;

pub use biological_neural_integration::BiologicalNeuralIntegrator;

pub use biological_neural_integration::BiologicalStatistics;

pub use biological_neural_integration::BiologicalValidationContext;

pub use biological_neural_integration::BiologicalValidationMode;

pub use biological_neural_integration::BiologicalValidationResult;

pub use biological_neural_integration::CellCultureConditions;

pub use biological_neural_integration::CellCultureConfig;

pub use biological_neural_integration::CultureId;

pub use biological_neural_integration::EnergyEfficiencyRequirements;

pub use biological_neural_integration::NeuralStimulationParameters;

pub use biological_neural_integration::NeurotransmitterConfig;

pub use biological_neural_integration::OrganoidConfig;

pub use biological_neural_integration::OrganoidId;

pub use biological_neural_integration::PlasticityConfig;

pub use biological_neural_integration::SignalProcessingConfig;

pub use biological_neural_integration::StimulationPattern;

pub use evolutionary_neural_architecture::ArchitecturePerformanceMetrics;

pub use evolutionary_neural_architecture::ConvergenceMetrics;

pub use evolutionary_neural_architecture::DiversityRequirements;

pub use evolutionary_neural_architecture::EvolutionaryConfig;

pub use evolutionary_neural_architecture::EvolutionaryInitResult;

pub use evolutionary_neural_architecture::EvolutionaryMetrics;

pub use evolutionary_neural_architecture::EvolutionaryNeuralArchitecture;

pub use evolutionary_neural_architecture::EvolutionaryValidationContext;

pub use evolutionary_neural_architecture::EvolutionaryValidationResult;

pub use evolutionary_neural_architecture::EvolvedArchitecture;

pub use evolutionary_neural_architecture::LayerType;

pub use evolutionary_neural_architecture::NASSearchStrategy;

pub use evolutionary_neural_architecture::NeuralArchitecture;

pub use evolutionary_neural_architecture::PerformanceTargets;

pub use evolutionary_neural_architecture::ResourceConstraints;

pub use evolutionary_neural_architecture::TopologyType as ArchTopologyType;

pub use owl_to_shacl::GeneratedShape;

pub use owl_to_shacl::OwlClass;

pub use owl_to_shacl::OwlConstructType;

pub use owl_to_shacl::OwlProperty;

pub use owl_to_shacl::OwlPropertyCharacteristic;

pub use owl_to_shacl::OwlRestriction;

pub use owl_to_shacl::OwlRestrictionType;

pub use owl_to_shacl::OwlToShaclConfig;

pub use owl_to_shacl::OwlToShaclTransfer;

pub use owl_to_shacl::TransferStats;

pub use config::AiModelConfig;

pub use config::AiModelType;

pub use config::FeatureConfig;

pub use config::FeatureNormalization;

pub use config::GlobalAiConfig;

pub use config::PerformanceThresholds;

pub use config::ShaclAiConfig;

pub use config::ShaclAiStatistics;

pub use config::TrainingConfig;

pub use data_types::default_instant;

pub use data_types::DataInconsistency;

pub use data_types::DistributionAnalysis;

pub use data_types::ExecutionTimeTrend;

pub use data_types::InconsistencyImpact;

pub use data_types::ModelTrainingResult;

pub use data_types::PerformanceData;

pub use data_types::PerformanceMetric;

pub use data_types::PerformanceTrend;

pub use data_types::RdfData;

pub use data_types::ShapeAnalysis;

pub use data_types::ShapeData;

pub use data_types::ThroughputTrend;

pub use data_types::TrainingDataset;

pub use data_types::TrainingResult;

pub use data_types::ValidationData;

pub use data_types::ViolationPattern;

pub use analytics::*;

pub use collaborative_development::*;

pub use deployment::*;

pub use evolution_strategies::*;

pub use forecasting_models::*;

pub use insights::*;

pub use optimization::*;

pub use patterns::*;

pub use performance_analytics::*;

pub use prediction::*;

pub use predictive_analytics::*;

pub use production_deployment::*;

pub use quality::*;

pub use recommendation_systems::*;

pub use self_adaptive_ai::*;

pub use shape::*;

pub use system_monitoring::*;

pub use validation_performance::*;

pub use version_control::*;

Modules

ab_testing

A/B Testing Framework for Model Comparison

advanced_features

Advanced features for SHACL-AI v0.1.0

advanced_neural

Advanced Neural Architectures for SHACL-AI

advanced_pattern_mining

Advanced Pattern Mining Engine for SHACL AI

advanced_scirs2_integration

Advanced SciRS2 Integration for SHACL AI

advanced_validation_strategies

Advanced Validation Strategies

advanced_visualization

Advanced Visualization Tools for SHACL-AI

ai_orchestrator

AI Orchestrator for Comprehensive Shape Learning

analytics

Analytics and insights engine for SHACL validation

anomaly_detection

Anomaly Detection Module for SHACL Validation

automated_retraining

Automated Retraining Pipelines for ML Models

bias_detection

Bias Detection and Mitigation for Fair AI

biological_neural_integration

Biological Neural Integration System

blockchain_validation

Blockchain Validation Module

change_detector

Schema change detection between two SHACL shape sets.

collaborative_development

Collaborative Shape Development

config

Configuration types for SHACL-AI operations

constraint_generation

Automatic Constraint Generation Module

constraint_inference

Data-driven SHACL constraint inference.

constraint_miner

Constraint Mining from RDF Data

constraint_ranker

SHACL constraint ranking by violation severity and impact.

constraint_synthesizer

Automated SHACL constraint synthesis from data samples.

crosslingual_transfer

Cross-lingual Shape Transfer

data_profiler

RDF data profiling for shape inference.

data_types

Data types for SHACL-AI insight generation and analysis

deployment

Deployment Strategies and Infrastructure Management

edge_deployment

Edge Deployment Support for ML Models

ensemble

Ensemble methods for SHACL shape inference

error_handling

Intelligent Error Handling System for SHACL-AI

evolution_strategies

Shape Evolution Strategies

evolutionary_neural_architecture

Evolutionary Neural Architecture System

experiment_tracking

Experiment Tracking System for ML Operations

explainable

Explainable AI module for SHACL-AI interpretability

explainable_ai

Explainable AI for SHACL-AI Interpretability

explainable_violations

Explainable AI for SHACL Violations

explanation_generator

Human-readable explanation generator for SHACL validation violations.

feature_store

Feature Store Integration for ML Operations

federated_learning

Federated Learning for Distributed SHACL Shape Learning

forecasting_models

Predictive Analytics Forecasting Models

gpu

GPU Acceleration Simulation for SHACL-AI

hyperparameter_optimization

Hyperparameter Optimization System

inference

Inference sub-modules for SHACL-AI

insights

AI-powered insights for SHACL validation and data quality

integration_testing

Enhanced Integration Testing Framework

interactive_labeling

Interactive Labeling Interface for Active Learning

knowledge_distillation

Knowledge Distillation for Model Compression

learning

Shape learning and automatic constraint discovery

llm

LLM integration for SHACL constraint generation

llm_integration

LLM-based SHACL shape suggestion and violation explanation.

memory_optimization

Memory optimization for AI operations

meta_learning

Meta-Learning for Few-Shot Pattern Recognition

ml

Machine learning models for shape learning

model_compression

Model Compression and Quantization for Efficient Deployment

model_drift_monitoring

Model Drift Monitoring System

model_governance

Model Governance and Compliance Framework

model_registry

Model Registry and Versioning System

models

Concrete ML model implementations for SHACL shape learning

multi_task_learning

Multi-Task Learning Framework for SHACL Validation

multimodal_validation

Multi-Modal Validation for SHACL-AI

neural_cost_estimation

Neural Cost Estimation Engine Module

neural_patterns

Neural Pattern Recognition for Advanced SHACL Shape Learning

neural_transformer_pattern_integration

Neural Transformer Pattern Integration for Advanced Query Optimization

neuromorphic_validation

Neuromorphic Computing for SHACL Validation

optimization

Validation optimization and performance tuning

optimization_engine

Advanced Shape Optimization Engine

orchestrator

AI Orchestrator for Comprehensive Shape Learning

owl_to_shacl

OWL to SHACL Transfer

pattern_learner

ML-Based SHACL Pattern Learner

pattern_scorer

SHACL shape pattern scoring and ranking.

patterns

Pattern recognition and analysis for RDF data

performance_analytics

Performance Analytics with Real-time Monitoring and Optimization

performance_benchmarking

Performance Benchmarking Framework Module

prediction

Validation prediction and outcome forecasting

predictive_analytics

Predictive Analytics with Forecasting Models and Recommendation Systems

production_deployment

Production Deployment Strategies

production_monitoring

Production Monitoring for ML Models

property_suggester

AI-assisted SHACL property suggestion from data patterns.

quality

Quality Assessment Module for SHACL-AI

realtime_adaptive_query_optimizer

Real-time Adaptive Query Optimizer with ML-driven Performance Optimization

realtime_anomaly_streams

Real-time Anomaly Detection Streams for Production Monitoring

recommendation_systems

Recommendation Systems for Shape Improvements and Validation Strategy Optimization

reinforcement_learning

Reinforcement Learning for SHACL Validation Optimization

report_formatter

SHACL Validation Report Formatter

resilience

Production resilience and error handling for AI operations

rule_generator

SHACL Rule Generator

scalability_testing

Scalability Testing Suite for SHACL-AI

schema_alignment

Schema alignment between ontologies.

security

Security Module for OxiRS AI Components

security_audit

Security Audit Framework for AI Models

self_adaptive_ai

Self-Adaptive AI for Continuous Learning and Improvement

shape

Shape building and constraint utilities

shape_evolver

Incremental SHACL shape evolution as RDF data changes.

shape_learning

Shape Learning Module for v0.3.0 Advanced SHACL AI

shape_management

Shape Management Module

shape_recommender

ML-based SHACL shape recommendations from data statistics.

sophisticated_validation_optimization

Sophisticated Validation Optimization Strategies

streaming_adaptation

Real-Time Streaming Adaptation for SHACL-AI

system_monitoring

Comprehensive System Monitoring for SHACL-AI

training

Training infrastructure for SHACL-AI models

validation_performance

Validation Performance Optimization Module

version_control

Shape Version Control System

violation_classifier

ML-style SHACL violation severity classification.

Structs

ShaclAiAssistant

AI-powered SHACL assistant for comprehensive validation enhancement

ShaclAiAssistantBuilder

Builder for creating SHACL-AI assistant with custom configuration

Enums

ShaclAiError

Core error type for SHACL-AI operations

Constants

VERSION

Version information for OxiRS SHACL-AI

Functions

init

Initialize OxiRS SHACL-AI with default configuration

Type Aliases

Result

Result type alias for SHACL-AI operations