scirs2_sparse/neural_adaptive_sparse/
mod.rs

1//! Neural-Adaptive Sparse Matrix Operations for Advanced Mode
2//!
3//! This module implements neural network-inspired adaptive algorithms for sparse matrix
4//! operations that learn and optimize based on matrix characteristics and usage patterns.
5//!
6//! ## Architecture
7//!
8//! The neural adaptive system consists of several interconnected components:
9//!
10//! - **Neural Networks**: Multi-layer perceptrons with attention mechanisms for pattern recognition
11//! - **Transformer Models**: Advanced attention-based models for complex pattern understanding
12//! - **Reinforcement Learning**: Agents that learn optimal strategies through trial and reward
13//! - **Pattern Memory**: Efficient storage and retrieval of learned optimization patterns
14//! - **Configuration**: Flexible configuration system for different use cases
15//!
16//! ## Usage
17//!
18//! ```rust,ignore
19//! use scirs2_sparse::neural_adaptive_sparse::{
20//!     NeuralAdaptiveSparseProcessor, NeuralAdaptiveConfig, OptimizationStrategy
21//! };
22//!
23//! // Create a configuration
24//! let config = NeuralAdaptiveConfig::default();
25//!
26//! // Create the processor
27//! let mut processor = NeuralAdaptiveSparseProcessor::new(config);
28//!
29//! // Use the processor to optimize matrix operations
30//! // (actual matrix features would be extracted from real sparse matrices)
31//! let matrix_features = vec![1.0, 2.0, 3.0]; // Simplified example
32//! let context = OperationContext {
33//!     matrix_shape: (1000, 1000),
34//!     nnz: 5000,
35//!     operation_type: OperationType::MatVec,
36//!     performance_target: PerformanceTarget::Speed,
37//! };
38//!
39//! let strategy = processor.optimize_operation::<f64>(&matrix_features, &context)?;
40//! ```
41//!
42//! ## Performance Learning
43//!
44//! The system learns from performance feedback to improve future optimizations:
45//!
46//! ```rust,ignore
47//! use scirs2_sparse::neural_adaptive_sparse::{PerformanceMetrics, OptimizationStrategy};
48//!
49//! // After executing the operation, provide performance feedback
50//! let performance = PerformanceMetrics::new(
51//!     0.1,  // execution_time
52//!     0.8,  // cache_efficiency
53//!     0.9,  // simd_utilization
54//!     0.7,  // parallel_efficiency
55//!     0.85, // memory_bandwidth
56//!     OptimizationStrategy::SIMDVectorized,
57//! );
58//!
59//! processor.learn_from_performance(
60//!     OptimizationStrategy::SIMDVectorized,
61//!     performance,
62//!     &matrix_features,
63//!     &context,
64//! )?;
65//! ```
66
67pub mod config;
68pub mod neural_network;
69pub mod pattern_memory;
70pub mod processor;
71pub mod reinforcement_learning;
72pub mod transformer;
73
74// Re-export main types for convenience
75pub use config::NeuralAdaptiveConfig;
76pub use pattern_memory::OptimizationStrategy;
77pub use processor::{
78    NeuralAdaptiveSparseProcessor, NeuralProcessorStats, OperationContext, OperationType,
79    PerformanceTarget, ProcessorState,
80};
81pub use reinforcement_learning::{PerformanceMetrics, RLAlgorithm};
82
83// Re-export key internal types that might be useful
84pub use neural_network::ActivationFunction;
85pub use transformer::{LayerGradients, TransformerGradients};
86
87#[cfg(test)]
88mod tests {
89    use super::*;
90
91    #[test]
92    fn test_neural_adaptive_config_creation() {
93        let config = NeuralAdaptiveConfig::new();
94        assert_eq!(config.hidden_layers, 3);
95        assert_eq!(config.neurons_per_layer, 64);
96        assert!(config.reinforcement_learning);
97    }
98
99    #[test]
100    fn test_config_builder_pattern() {
101        let config = NeuralAdaptiveConfig::new()
102            .with_hidden_layers(2)
103            .with_neurons_per_layer(32)
104            .with_learning_rate(0.01)
105            .with_reinforcement_learning(false);
106
107        assert_eq!(config.hidden_layers, 2);
108        assert_eq!(config.neurons_per_layer, 32);
109        assert_eq!(config.learningrate, 0.01);
110        assert!(!config.reinforcement_learning);
111    }
112
113    #[test]
114    fn test_config_validation() {
115        let mut config = NeuralAdaptiveConfig::new();
116        assert!(config.validate().is_ok());
117
118        config.hidden_layers = 0;
119        assert!(config.validate().is_err());
120
121        config.hidden_layers = 3;
122        config.learningrate = -0.1;
123        assert!(config.validate().is_err());
124
125        config.learningrate = 0.001;
126        config.modeldim = 63; // Not divisible by attention_heads (8)
127        assert!(config.validate().is_err());
128    }
129
130    #[test]
131    fn test_predefined_configurations() {
132        let lightweight = NeuralAdaptiveConfig::lightweight();
133        assert_eq!(lightweight.hidden_layers, 2);
134        assert_eq!(lightweight.neurons_per_layer, 16);
135        assert!(!lightweight.self_attention);
136
137        let high_perf = NeuralAdaptiveConfig::high_performance();
138        assert_eq!(high_perf.hidden_layers, 5);
139        assert_eq!(high_perf.neurons_per_layer, 128);
140        assert!(high_perf.self_attention);
141
142        let mem_efficient = NeuralAdaptiveConfig::memory_efficient();
143        assert_eq!(mem_efficient.hidden_layers, 2);
144        assert_eq!(mem_efficient.memory_capacity, 1000);
145        assert!(!mem_efficient.reinforcement_learning);
146    }
147
148    #[test]
149    fn test_processor_creation() {
150        let config = NeuralAdaptiveConfig::lightweight();
151        let processor = NeuralAdaptiveSparseProcessor::new(config);
152
153        let stats = processor.get_statistics();
154        assert_eq!(stats.total_operations, 0);
155        assert_eq!(stats.successful_adaptations, 0);
156    }
157
158    #[test]
159    fn test_operation_context() {
160        let context = OperationContext {
161            matrix_shape: (1000, 1000),
162            nnz: 5000,
163            operation_type: OperationType::MatVec,
164            performance_target: PerformanceTarget::Speed,
165        };
166
167        assert_eq!(context.matrix_shape, (1000, 1000));
168        assert_eq!(context.nnz, 5000);
169    }
170
171    #[test]
172    fn test_performance_metrics() {
173        let performance = PerformanceMetrics::new(
174            0.1,  // execution_time
175            0.8,  // cache_efficiency
176            0.9,  // simd_utilization
177            0.7,  // parallel_efficiency
178            0.85, // memory_bandwidth
179            OptimizationStrategy::SIMDVectorized,
180        );
181
182        let reward = performance.compute_reward(0.2); // baseline_time
183        assert!(reward > 0.0); // Should be positive since we improved time
184
185        let score = performance.performance_score();
186        assert!(score > 0.0 && score <= 1.0);
187    }
188
189    #[test]
190    fn test_optimization_strategies() {
191        // Test all optimization strategies are accessible
192        let strategies = [
193            OptimizationStrategy::RowWiseCache,
194            OptimizationStrategy::ColumnWiseLocality,
195            OptimizationStrategy::BlockStructured,
196            OptimizationStrategy::DiagonalOptimized,
197            OptimizationStrategy::Hierarchical,
198            OptimizationStrategy::StreamingCompute,
199            OptimizationStrategy::SIMDVectorized,
200            OptimizationStrategy::ParallelWorkStealing,
201            OptimizationStrategy::AdaptiveHybrid,
202        ];
203
204        assert_eq!(strategies.len(), 9);
205
206        // Test that they can be used as hash keys
207        use std::collections::HashMap;
208        let mut strategy_map = HashMap::new();
209        for strategy in &strategies {
210            strategy_map.insert(*strategy, 1.0);
211        }
212        assert_eq!(strategy_map.len(), 9);
213    }
214
215    #[test]
216    fn test_rl_algorithms() {
217        // Test all RL algorithms are accessible
218        let algorithms = [
219            RLAlgorithm::DQN,
220            RLAlgorithm::PolicyGradient,
221            RLAlgorithm::ActorCritic,
222            RLAlgorithm::PPO,
223            RLAlgorithm::SAC,
224        ];
225
226        assert_eq!(algorithms.len(), 5);
227
228        // Test configuration with different algorithms
229        for algorithm in &algorithms {
230            let config = NeuralAdaptiveConfig::new().with_rl_algorithm(*algorithm);
231            assert!(config.validate().is_ok());
232        }
233    }
234
235    #[test]
236    fn test_processor_state_serialization() {
237        let config = NeuralAdaptiveConfig::lightweight();
238        let processor = NeuralAdaptiveSparseProcessor::new(config);
239
240        let state = processor.save_state();
241        assert_eq!(state.total_operations, 0);
242        assert!(state.neural_network_params.len() > 0);
243
244        // Test that state can be loaded (this would require a mutable processor in real usage)
245        // Just test the state structure for now
246        assert!(state.current_exploration_rate > 0.0);
247        assert!(state.current_exploration_rate <= 1.0);
248    }
249}
scirs2_sparse/neural_adaptive_sparse/mod.rs

scirs2_sparse/neural_adaptive_sparse/
mod.rs
