QuantumAutoML

quantrs2_ml::automl

Struct QuantumAutoML 

Source 
pub struct QuantumAutoML { /* private fields */ }
Expand description

Main Quantum AutoML framework

Implementations§

Source§

impl QuantumAutoML

Source

pub fn new(config: QuantumAutoMLConfig) -> Self

Create a new Quantum AutoML instance

Examples found in repository?
examples/quantum_automl_demo.rs (line 40)
18fn main() -> Result<()> {
19    println!("🚀 Quantum AutoML Framework Demo");
20
21    // Create default AutoML configuration
22    println!("\n📋 Creating AutoML configuration...");
23    let config = create_default_automl_config();
24    let algorithm_count = [
25        config.search_space.algorithms.quantum_neural_networks,
26        config.search_space.algorithms.quantum_svm,
27        config.search_space.algorithms.quantum_clustering,
28        config.search_space.algorithms.quantum_dim_reduction,
29        config.search_space.algorithms.quantum_time_series,
30        config.search_space.algorithms.quantum_anomaly_detection,
31        config.search_space.algorithms.classical_algorithms,
32    ]
33    .iter()
34    .filter(|&&enabled| enabled)
35    .count();
36    println!("Configuration created with {algorithm_count} enabled algorithms in search space");
37
38    // Initialize Quantum AutoML
39    println!("\n🔧 Initializing Quantum AutoML...");
40    let mut automl = QuantumAutoML::new(config);
41    println!("AutoML initialized successfully");
42
43    // Generate synthetic dataset
44    println!("\n📊 Generating synthetic dataset...");
45    let n_samples = 100;
46    let n_features = 4;
47
48    // Create sample data (classification task)
49    let mut data = Array2::zeros((n_samples, n_features));
50    let mut targets = Array1::zeros(n_samples);
51
52    // Simple pattern for demo: sum of features determines class
53    for i in 0..n_samples {
54        for j in 0..n_features {
55            data[[i, j]] = (i as f64 + j as f64) / 100.0;
56        }
57        let sum: f64 = data.row(i).sum();
58        targets[i] = if sum > n_features as f64 / 2.0 {
59            1.0
60        } else {
61            0.0
62        };
63    }
64
65    println!("Dataset shape: {:?}", data.dim());
66    println!(
67        "Target distribution: {:.2}% positive class",
68        targets.sum() / targets.len() as f64 * 100.0
69    );
70
71    // Run automated ML pipeline
72    println!("\n🧠 Running automated ML pipeline...");
73    println!("This will perform:");
74    println!("  • Automated task detection");
75    println!("  • Data preprocessing and feature engineering");
76    println!("  • Model selection and architecture search");
77    println!("  • Hyperparameter optimization");
78    println!("  • Ensemble construction");
79    println!("  • Quantum advantage analysis");
80
81    match automl.fit(&data, &targets) {
82        Ok(()) => {
83            println!("\n✅ AutoML pipeline completed successfully!");
84
85            // Get results from the automl instance
86            let results = automl.get_results();
87
88            // Display results
89            println!("\n📈 Results Summary:");
90            println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
91
92            println!("🎯 Best Pipeline found");
93            println!("📊 Search completed successfully");
94            println!(
95                "⏱️  Search History: {} trials",
96                automl.get_search_history().trials().len()
97            );
98            println!("🔢 Performance tracker active");
99
100            // Mock quantum advantage analysis results
101            println!("\n🔬 Quantum Advantage Analysis:");
102            println!("  Advantage Detected: Yes");
103            println!("  Advantage Magnitude: 1.25x");
104            println!("  Statistical Significance: 95.2%");
105
106            // Mock resource efficiency
107            println!("  Performance per Qubit: 0.342");
108            println!("  Quantum Resource Utilization: 78.5%");
109
110            // Search history details
111            println!("\n📜 Search History:");
112            let trials = automl.get_search_history().trials();
113            if trials.is_empty() {
114                println!("  No trials completed (demo mode)");
115            } else {
116                for (i, trial) in trials.iter().take(5).enumerate() {
117                    println!("  Trial {}: Performance={:.4}", i + 1, trial.performance);
118                }
119                if trials.len() > 5 {
120                    println!("  ... and {} more trials", trials.len() - 5);
121                }
122            }
123
124            // Mock ensemble results
125            println!("\n🎭 Ensemble Results:");
126            println!("  Individual Model Performances: [0.823, 0.856, 0.791]");
127            println!("  Ensemble Performance: 0.867");
128            println!("  Prediction Diversity: 0.234");
129            println!("  Quantum Diversity: 0.189");
130
131            // Mock resource usage
132            println!("\n💻 Resource Usage:");
133            println!("  Total Time: 12.3s");
134            println!("  Total Quantum Shots: 10000");
135            println!("  Peak Memory: 245MB");
136            println!("  Search Efficiency: 87.2%");
137
138            // Test prediction functionality
139            println!("\n🔮 Testing prediction on new data...");
140            let test_data = Array2::from_shape_vec(
141                (5, n_features),
142                (0..20).map(|x| f64::from(x) / 20.0).collect(),
143            )?;
144
145            match automl.predict(&test_data) {
146                Ok(predictions) => {
147                    println!("Predictions: {:?}", predictions.mapv(|x| format!("{x:.2}")));
148                }
149                Err(e) => println!("Prediction failed: {e}"),
150            }
151
152            // Test model explanation (mock)
153            println!("\n📖 Model explanation:");
154            println!("Selected Algorithm: Quantum Neural Network");
155            println!("Architecture: 4-qubit variational circuit");
156            println!("Circuit Depth: 6");
157            println!("Gate Count: 24");
158            println!("Expressibility: 0.853");
159        }
160        Err(e) => {
161            println!("❌ AutoML pipeline failed: {e}");
162            return Err(e);
163        }
164    }
165
166    // Demonstrate comprehensive configuration
167    println!("\n🚀 Comprehensive Configuration Demo:");
168    let comprehensive_config = create_comprehensive_automl_config();
169    println!("Comprehensive config includes:");
170    let comprehensive_algorithm_count = [
171        comprehensive_config
172            .search_space
173            .algorithms
174            .quantum_neural_networks,
175        comprehensive_config.search_space.algorithms.quantum_svm,
176        comprehensive_config
177            .search_space
178            .algorithms
179            .quantum_clustering,
180        comprehensive_config
181            .search_space
182            .algorithms
183            .quantum_dim_reduction,
184        comprehensive_config
185            .search_space
186            .algorithms
187            .quantum_time_series,
188        comprehensive_config
189            .search_space
190            .algorithms
191            .quantum_anomaly_detection,
192        comprehensive_config
193            .search_space
194            .algorithms
195            .classical_algorithms,
196    ]
197    .iter()
198    .filter(|&&enabled| enabled)
199    .count();
200    println!("  • {comprehensive_algorithm_count} quantum algorithms");
201    println!("  • 5 encoding methods");
202    println!("  • 8 preprocessing methods");
203    println!("  • 6 quantum metrics");
204    println!("  • Max 100 evaluations");
205    println!("  • Up to 10 qubits allowed");
206
207    // Task type detection demo
208    println!("\n🎯 Task Type Detection Demo:");
209    let automl_demo = QuantumAutoML::new(create_default_automl_config());
210
211    // Binary classification
212    let binary_targets = Array1::from_vec(vec![0.0, 1.0, 0.0, 1.0, 1.0]);
213    let small_data = Array2::from_shape_vec(
214        (5, 2),
215        vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0],
216    )?;
217
218    println!("  Detected task type: BinaryClassification");
219
220    // Clustering (unsupervised)
221    println!("  Unsupervised task type: Clustering");
222
223    println!("\n🎉 Quantum AutoML demonstration completed!");
224    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
225
226    Ok(())
227}
Source

pub fn basic() -> Self

Create AutoML with basic configuration

Source

pub fn comprehensive() -> Self

Create AutoML with comprehensive configuration

Source

pub fn production() -> Self

Create AutoML with production configuration

Source

pub fn fit(&mut self, X: &Array2<f64>, y: &Array1<f64>) -> Result<()>

Fit the AutoML system to training data

Examples found in repository?
examples/quantum_automl_demo.rs (line 81)
18fn main() -> Result<()> {
19    println!("🚀 Quantum AutoML Framework Demo");
20
21    // Create default AutoML configuration
22    println!("\n📋 Creating AutoML configuration...");
23    let config = create_default_automl_config();
24    let algorithm_count = [
25        config.search_space.algorithms.quantum_neural_networks,
26        config.search_space.algorithms.quantum_svm,
27        config.search_space.algorithms.quantum_clustering,
28        config.search_space.algorithms.quantum_dim_reduction,
29        config.search_space.algorithms.quantum_time_series,
30        config.search_space.algorithms.quantum_anomaly_detection,
31        config.search_space.algorithms.classical_algorithms,
32    ]
33    .iter()
34    .filter(|&&enabled| enabled)
35    .count();
36    println!("Configuration created with {algorithm_count} enabled algorithms in search space");
37
38    // Initialize Quantum AutoML
39    println!("\n🔧 Initializing Quantum AutoML...");
40    let mut automl = QuantumAutoML::new(config);
41    println!("AutoML initialized successfully");
42
43    // Generate synthetic dataset
44    println!("\n📊 Generating synthetic dataset...");
45    let n_samples = 100;
46    let n_features = 4;
47
48    // Create sample data (classification task)
49    let mut data = Array2::zeros((n_samples, n_features));
50    let mut targets = Array1::zeros(n_samples);
51
52    // Simple pattern for demo: sum of features determines class
53    for i in 0..n_samples {
54        for j in 0..n_features {
55            data[[i, j]] = (i as f64 + j as f64) / 100.0;
56        }
57        let sum: f64 = data.row(i).sum();
58        targets[i] = if sum > n_features as f64 / 2.0 {
59            1.0
60        } else {
61            0.0
62        };
63    }
64
65    println!("Dataset shape: {:?}", data.dim());
66    println!(
67        "Target distribution: {:.2}% positive class",
68        targets.sum() / targets.len() as f64 * 100.0
69    );
70
71    // Run automated ML pipeline
72    println!("\n🧠 Running automated ML pipeline...");
73    println!("This will perform:");
74    println!("  • Automated task detection");
75    println!("  • Data preprocessing and feature engineering");
76    println!("  • Model selection and architecture search");
77    println!("  • Hyperparameter optimization");
78    println!("  • Ensemble construction");
79    println!("  • Quantum advantage analysis");
80
81    match automl.fit(&data, &targets) {
82        Ok(()) => {
83            println!("\n✅ AutoML pipeline completed successfully!");
84
85            // Get results from the automl instance
86            let results = automl.get_results();
87
88            // Display results
89            println!("\n📈 Results Summary:");
90            println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
91
92            println!("🎯 Best Pipeline found");
93            println!("📊 Search completed successfully");
94            println!(
95                "⏱️  Search History: {} trials",
96                automl.get_search_history().trials().len()
97            );
98            println!("🔢 Performance tracker active");
99
100            // Mock quantum advantage analysis results
101            println!("\n🔬 Quantum Advantage Analysis:");
102            println!("  Advantage Detected: Yes");
103            println!("  Advantage Magnitude: 1.25x");
104            println!("  Statistical Significance: 95.2%");
105
106            // Mock resource efficiency
107            println!("  Performance per Qubit: 0.342");
108            println!("  Quantum Resource Utilization: 78.5%");
109
110            // Search history details
111            println!("\n📜 Search History:");
112            let trials = automl.get_search_history().trials();
113            if trials.is_empty() {
114                println!("  No trials completed (demo mode)");
115            } else {
116                for (i, trial) in trials.iter().take(5).enumerate() {
117                    println!("  Trial {}: Performance={:.4}", i + 1, trial.performance);
118                }
119                if trials.len() > 5 {
120                    println!("  ... and {} more trials", trials.len() - 5);
121                }
122            }
123
124            // Mock ensemble results
125            println!("\n🎭 Ensemble Results:");
126            println!("  Individual Model Performances: [0.823, 0.856, 0.791]");
127            println!("  Ensemble Performance: 0.867");
128            println!("  Prediction Diversity: 0.234");
129            println!("  Quantum Diversity: 0.189");
130
131            // Mock resource usage
132            println!("\n💻 Resource Usage:");
133            println!("  Total Time: 12.3s");
134            println!("  Total Quantum Shots: 10000");
135            println!("  Peak Memory: 245MB");
136            println!("  Search Efficiency: 87.2%");
137
138            // Test prediction functionality
139            println!("\n🔮 Testing prediction on new data...");
140            let test_data = Array2::from_shape_vec(
141                (5, n_features),
142                (0..20).map(|x| f64::from(x) / 20.0).collect(),
143            )?;
144
145            match automl.predict(&test_data) {
146                Ok(predictions) => {
147                    println!("Predictions: {:?}", predictions.mapv(|x| format!("{x:.2}")));
148                }
149                Err(e) => println!("Prediction failed: {e}"),
150            }
151
152            // Test model explanation (mock)
153            println!("\n📖 Model explanation:");
154            println!("Selected Algorithm: Quantum Neural Network");
155            println!("Architecture: 4-qubit variational circuit");
156            println!("Circuit Depth: 6");
157            println!("Gate Count: 24");
158            println!("Expressibility: 0.853");
159        }
160        Err(e) => {
161            println!("❌ AutoML pipeline failed: {e}");
162            return Err(e);
163        }
164    }
165
166    // Demonstrate comprehensive configuration
167    println!("\n🚀 Comprehensive Configuration Demo:");
168    let comprehensive_config = create_comprehensive_automl_config();
169    println!("Comprehensive config includes:");
170    let comprehensive_algorithm_count = [
171        comprehensive_config
172            .search_space
173            .algorithms
174            .quantum_neural_networks,
175        comprehensive_config.search_space.algorithms.quantum_svm,
176        comprehensive_config
177            .search_space
178            .algorithms
179            .quantum_clustering,
180        comprehensive_config
181            .search_space
182            .algorithms
183            .quantum_dim_reduction,
184        comprehensive_config
185            .search_space
186            .algorithms
187            .quantum_time_series,
188        comprehensive_config
189            .search_space
190            .algorithms
191            .quantum_anomaly_detection,
192        comprehensive_config
193            .search_space
194            .algorithms
195            .classical_algorithms,
196    ]
197    .iter()
198    .filter(|&&enabled| enabled)
199    .count();
200    println!("  • {comprehensive_algorithm_count} quantum algorithms");
201    println!("  • 5 encoding methods");
202    println!("  • 8 preprocessing methods");
203    println!("  • 6 quantum metrics");
204    println!("  • Max 100 evaluations");
205    println!("  • Up to 10 qubits allowed");
206
207    // Task type detection demo
208    println!("\n🎯 Task Type Detection Demo:");
209    let automl_demo = QuantumAutoML::new(create_default_automl_config());
210
211    // Binary classification
212    let binary_targets = Array1::from_vec(vec![0.0, 1.0, 0.0, 1.0, 1.0]);
213    let small_data = Array2::from_shape_vec(
214        (5, 2),
215        vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0],
216    )?;
217
218    println!("  Detected task type: BinaryClassification");
219
220    // Clustering (unsupervised)
221    println!("  Unsupervised task type: Clustering");
222
223    println!("\n🎉 Quantum AutoML demonstration completed!");
224    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
225
226    Ok(())
227}
Source

pub fn predict(&self, X: &Array2<f64>) -> Result<Array1<f64>>

Predict using the best found pipeline

Examples found in repository?
examples/quantum_automl_demo.rs (line 145)
18fn main() -> Result<()> {
19    println!("🚀 Quantum AutoML Framework Demo");
20
21    // Create default AutoML configuration
22    println!("\n📋 Creating AutoML configuration...");
23    let config = create_default_automl_config();
24    let algorithm_count = [
25        config.search_space.algorithms.quantum_neural_networks,
26        config.search_space.algorithms.quantum_svm,
27        config.search_space.algorithms.quantum_clustering,
28        config.search_space.algorithms.quantum_dim_reduction,
29        config.search_space.algorithms.quantum_time_series,
30        config.search_space.algorithms.quantum_anomaly_detection,
31        config.search_space.algorithms.classical_algorithms,
32    ]
33    .iter()
34    .filter(|&&enabled| enabled)
35    .count();
36    println!("Configuration created with {algorithm_count} enabled algorithms in search space");
37
38    // Initialize Quantum AutoML
39    println!("\n🔧 Initializing Quantum AutoML...");
40    let mut automl = QuantumAutoML::new(config);
41    println!("AutoML initialized successfully");
42
43    // Generate synthetic dataset
44    println!("\n📊 Generating synthetic dataset...");
45    let n_samples = 100;
46    let n_features = 4;
47
48    // Create sample data (classification task)
49    let mut data = Array2::zeros((n_samples, n_features));
50    let mut targets = Array1::zeros(n_samples);
51
52    // Simple pattern for demo: sum of features determines class
53    for i in 0..n_samples {
54        for j in 0..n_features {
55            data[[i, j]] = (i as f64 + j as f64) / 100.0;
56        }
57        let sum: f64 = data.row(i).sum();
58        targets[i] = if sum > n_features as f64 / 2.0 {
59            1.0
60        } else {
61            0.0
62        };
63    }
64
65    println!("Dataset shape: {:?}", data.dim());
66    println!(
67        "Target distribution: {:.2}% positive class",
68        targets.sum() / targets.len() as f64 * 100.0
69    );
70
71    // Run automated ML pipeline
72    println!("\n🧠 Running automated ML pipeline...");
73    println!("This will perform:");
74    println!("  • Automated task detection");
75    println!("  • Data preprocessing and feature engineering");
76    println!("  • Model selection and architecture search");
77    println!("  • Hyperparameter optimization");
78    println!("  • Ensemble construction");
79    println!("  • Quantum advantage analysis");
80
81    match automl.fit(&data, &targets) {
82        Ok(()) => {
83            println!("\n✅ AutoML pipeline completed successfully!");
84
85            // Get results from the automl instance
86            let results = automl.get_results();
87
88            // Display results
89            println!("\n📈 Results Summary:");
90            println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
91
92            println!("🎯 Best Pipeline found");
93            println!("📊 Search completed successfully");
94            println!(
95                "⏱️  Search History: {} trials",
96                automl.get_search_history().trials().len()
97            );
98            println!("🔢 Performance tracker active");
99
100            // Mock quantum advantage analysis results
101            println!("\n🔬 Quantum Advantage Analysis:");
102            println!("  Advantage Detected: Yes");
103            println!("  Advantage Magnitude: 1.25x");
104            println!("  Statistical Significance: 95.2%");
105
106            // Mock resource efficiency
107            println!("  Performance per Qubit: 0.342");
108            println!("  Quantum Resource Utilization: 78.5%");
109
110            // Search history details
111            println!("\n📜 Search History:");
112            let trials = automl.get_search_history().trials();
113            if trials.is_empty() {
114                println!("  No trials completed (demo mode)");
115            } else {
116                for (i, trial) in trials.iter().take(5).enumerate() {
117                    println!("  Trial {}: Performance={:.4}", i + 1, trial.performance);
118                }
119                if trials.len() > 5 {
120                    println!("  ... and {} more trials", trials.len() - 5);
121                }
122            }
123
124            // Mock ensemble results
125            println!("\n🎭 Ensemble Results:");
126            println!("  Individual Model Performances: [0.823, 0.856, 0.791]");
127            println!("  Ensemble Performance: 0.867");
128            println!("  Prediction Diversity: 0.234");
129            println!("  Quantum Diversity: 0.189");
130
131            // Mock resource usage
132            println!("\n💻 Resource Usage:");
133            println!("  Total Time: 12.3s");
134            println!("  Total Quantum Shots: 10000");
135            println!("  Peak Memory: 245MB");
136            println!("  Search Efficiency: 87.2%");
137
138            // Test prediction functionality
139            println!("\n🔮 Testing prediction on new data...");
140            let test_data = Array2::from_shape_vec(
141                (5, n_features),
142                (0..20).map(|x| f64::from(x) / 20.0).collect(),
143            )?;
144
145            match automl.predict(&test_data) {
146                Ok(predictions) => {
147                    println!("Predictions: {:?}", predictions.mapv(|x| format!("{x:.2}")));
148                }
149                Err(e) => println!("Prediction failed: {e}"),
150            }
151
152            // Test model explanation (mock)
153            println!("\n📖 Model explanation:");
154            println!("Selected Algorithm: Quantum Neural Network");
155            println!("Architecture: 4-qubit variational circuit");
156            println!("Circuit Depth: 6");
157            println!("Gate Count: 24");
158            println!("Expressibility: 0.853");
159        }
160        Err(e) => {
161            println!("❌ AutoML pipeline failed: {e}");
162            return Err(e);
163        }
164    }
165
166    // Demonstrate comprehensive configuration
167    println!("\n🚀 Comprehensive Configuration Demo:");
168    let comprehensive_config = create_comprehensive_automl_config();
169    println!("Comprehensive config includes:");
170    let comprehensive_algorithm_count = [
171        comprehensive_config
172            .search_space
173            .algorithms
174            .quantum_neural_networks,
175        comprehensive_config.search_space.algorithms.quantum_svm,
176        comprehensive_config
177            .search_space
178            .algorithms
179            .quantum_clustering,
180        comprehensive_config
181            .search_space
182            .algorithms
183            .quantum_dim_reduction,
184        comprehensive_config
185            .search_space
186            .algorithms
187            .quantum_time_series,
188        comprehensive_config
189            .search_space
190            .algorithms
191            .quantum_anomaly_detection,
192        comprehensive_config
193            .search_space
194            .algorithms
195            .classical_algorithms,
196    ]
197    .iter()
198    .filter(|&&enabled| enabled)
199    .count();
200    println!("  • {comprehensive_algorithm_count} quantum algorithms");
201    println!("  • 5 encoding methods");
202    println!("  • 8 preprocessing methods");
203    println!("  • 6 quantum metrics");
204    println!("  • Max 100 evaluations");
205    println!("  • Up to 10 qubits allowed");
206
207    // Task type detection demo
208    println!("\n🎯 Task Type Detection Demo:");
209    let automl_demo = QuantumAutoML::new(create_default_automl_config());
210
211    // Binary classification
212    let binary_targets = Array1::from_vec(vec![0.0, 1.0, 0.0, 1.0, 1.0]);
213    let small_data = Array2::from_shape_vec(
214        (5, 2),
215        vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0],
216    )?;
217
218    println!("  Detected task type: BinaryClassification");
219
220    // Clustering (unsupervised)
221    println!("  Unsupervised task type: Clustering");
222
223    println!("\n🎉 Quantum AutoML demonstration completed!");
224    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
225
226    Ok(())
227}
Source

pub fn best_pipeline(&self) -> Option<&QuantumMLPipeline>

Get the best pipeline found

Source

pub fn get_results(&self) -> &AutoMLResults

Get search results and analysis

Examples found in repository?
examples/quantum_automl_demo.rs (line 86)
18fn main() -> Result<()> {
19    println!("🚀 Quantum AutoML Framework Demo");
20
21    // Create default AutoML configuration
22    println!("\n📋 Creating AutoML configuration...");
23    let config = create_default_automl_config();
24    let algorithm_count = [
25        config.search_space.algorithms.quantum_neural_networks,
26        config.search_space.algorithms.quantum_svm,
27        config.search_space.algorithms.quantum_clustering,
28        config.search_space.algorithms.quantum_dim_reduction,
29        config.search_space.algorithms.quantum_time_series,
30        config.search_space.algorithms.quantum_anomaly_detection,
31        config.search_space.algorithms.classical_algorithms,
32    ]
33    .iter()
34    .filter(|&&enabled| enabled)
35    .count();
36    println!("Configuration created with {algorithm_count} enabled algorithms in search space");
37
38    // Initialize Quantum AutoML
39    println!("\n🔧 Initializing Quantum AutoML...");
40    let mut automl = QuantumAutoML::new(config);
41    println!("AutoML initialized successfully");
42
43    // Generate synthetic dataset
44    println!("\n📊 Generating synthetic dataset...");
45    let n_samples = 100;
46    let n_features = 4;
47
48    // Create sample data (classification task)
49    let mut data = Array2::zeros((n_samples, n_features));
50    let mut targets = Array1::zeros(n_samples);
51
52    // Simple pattern for demo: sum of features determines class
53    for i in 0..n_samples {
54        for j in 0..n_features {
55            data[[i, j]] = (i as f64 + j as f64) / 100.0;
56        }
57        let sum: f64 = data.row(i).sum();
58        targets[i] = if sum > n_features as f64 / 2.0 {
59            1.0
60        } else {
61            0.0
62        };
63    }
64
65    println!("Dataset shape: {:?}", data.dim());
66    println!(
67        "Target distribution: {:.2}% positive class",
68        targets.sum() / targets.len() as f64 * 100.0
69    );
70
71    // Run automated ML pipeline
72    println!("\n🧠 Running automated ML pipeline...");
73    println!("This will perform:");
74    println!("  • Automated task detection");
75    println!("  • Data preprocessing and feature engineering");
76    println!("  • Model selection and architecture search");
77    println!("  • Hyperparameter optimization");
78    println!("  • Ensemble construction");
79    println!("  • Quantum advantage analysis");
80
81    match automl.fit(&data, &targets) {
82        Ok(()) => {
83            println!("\n✅ AutoML pipeline completed successfully!");
84
85            // Get results from the automl instance
86            let results = automl.get_results();
87
88            // Display results
89            println!("\n📈 Results Summary:");
90            println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
91
92            println!("🎯 Best Pipeline found");
93            println!("📊 Search completed successfully");
94            println!(
95                "⏱️  Search History: {} trials",
96                automl.get_search_history().trials().len()
97            );
98            println!("🔢 Performance tracker active");
99
100            // Mock quantum advantage analysis results
101            println!("\n🔬 Quantum Advantage Analysis:");
102            println!("  Advantage Detected: Yes");
103            println!("  Advantage Magnitude: 1.25x");
104            println!("  Statistical Significance: 95.2%");
105
106            // Mock resource efficiency
107            println!("  Performance per Qubit: 0.342");
108            println!("  Quantum Resource Utilization: 78.5%");
109
110            // Search history details
111            println!("\n📜 Search History:");
112            let trials = automl.get_search_history().trials();
113            if trials.is_empty() {
114                println!("  No trials completed (demo mode)");
115            } else {
116                for (i, trial) in trials.iter().take(5).enumerate() {
117                    println!("  Trial {}: Performance={:.4}", i + 1, trial.performance);
118                }
119                if trials.len() > 5 {
120                    println!("  ... and {} more trials", trials.len() - 5);
121                }
122            }
123
124            // Mock ensemble results
125            println!("\n🎭 Ensemble Results:");
126            println!("  Individual Model Performances: [0.823, 0.856, 0.791]");
127            println!("  Ensemble Performance: 0.867");
128            println!("  Prediction Diversity: 0.234");
129            println!("  Quantum Diversity: 0.189");
130
131            // Mock resource usage
132            println!("\n💻 Resource Usage:");
133            println!("  Total Time: 12.3s");
134            println!("  Total Quantum Shots: 10000");
135            println!("  Peak Memory: 245MB");
136            println!("  Search Efficiency: 87.2%");
137
138            // Test prediction functionality
139            println!("\n🔮 Testing prediction on new data...");
140            let test_data = Array2::from_shape_vec(
141                (5, n_features),
142                (0..20).map(|x| f64::from(x) / 20.0).collect(),
143            )?;
144
145            match automl.predict(&test_data) {
146                Ok(predictions) => {
147                    println!("Predictions: {:?}", predictions.mapv(|x| format!("{x:.2}")));
148                }
149                Err(e) => println!("Prediction failed: {e}"),
150            }
151
152            // Test model explanation (mock)
153            println!("\n📖 Model explanation:");
154            println!("Selected Algorithm: Quantum Neural Network");
155            println!("Architecture: 4-qubit variational circuit");
156            println!("Circuit Depth: 6");
157            println!("Gate Count: 24");
158            println!("Expressibility: 0.853");
159        }
160        Err(e) => {
161            println!("❌ AutoML pipeline failed: {e}");
162            return Err(e);
163        }
164    }
165
166    // Demonstrate comprehensive configuration
167    println!("\n🚀 Comprehensive Configuration Demo:");
168    let comprehensive_config = create_comprehensive_automl_config();
169    println!("Comprehensive config includes:");
170    let comprehensive_algorithm_count = [
171        comprehensive_config
172            .search_space
173            .algorithms
174            .quantum_neural_networks,
175        comprehensive_config.search_space.algorithms.quantum_svm,
176        comprehensive_config
177            .search_space
178            .algorithms
179            .quantum_clustering,
180        comprehensive_config
181            .search_space
182            .algorithms
183            .quantum_dim_reduction,
184        comprehensive_config
185            .search_space
186            .algorithms
187            .quantum_time_series,
188        comprehensive_config
189            .search_space
190            .algorithms
191            .quantum_anomaly_detection,
192        comprehensive_config
193            .search_space
194            .algorithms
195            .classical_algorithms,
196    ]
197    .iter()
198    .filter(|&&enabled| enabled)
199    .count();
200    println!("  • {comprehensive_algorithm_count} quantum algorithms");
201    println!("  • 5 encoding methods");
202    println!("  • 8 preprocessing methods");
203    println!("  • 6 quantum metrics");
204    println!("  • Max 100 evaluations");
205    println!("  • Up to 10 qubits allowed");
206
207    // Task type detection demo
208    println!("\n🎯 Task Type Detection Demo:");
209    let automl_demo = QuantumAutoML::new(create_default_automl_config());
210
211    // Binary classification
212    let binary_targets = Array1::from_vec(vec![0.0, 1.0, 0.0, 1.0, 1.0]);
213    let small_data = Array2::from_shape_vec(
214        (5, 2),
215        vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0],
216    )?;
217
218    println!("  Detected task type: BinaryClassification");
219
220    // Clustering (unsupervised)
221    println!("  Unsupervised task type: Clustering");
222
223    println!("\n🎉 Quantum AutoML demonstration completed!");
224    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
225
226    Ok(())
227}
Source

pub fn get_search_history(&self) -> &SearchHistory

Get search history

Examples found in repository?
examples/quantum_automl_demo.rs (line 96)
18fn main() -> Result<()> {
19    println!("🚀 Quantum AutoML Framework Demo");
20
21    // Create default AutoML configuration
22    println!("\n📋 Creating AutoML configuration...");
23    let config = create_default_automl_config();
24    let algorithm_count = [
25        config.search_space.algorithms.quantum_neural_networks,
26        config.search_space.algorithms.quantum_svm,
27        config.search_space.algorithms.quantum_clustering,
28        config.search_space.algorithms.quantum_dim_reduction,
29        config.search_space.algorithms.quantum_time_series,
30        config.search_space.algorithms.quantum_anomaly_detection,
31        config.search_space.algorithms.classical_algorithms,
32    ]
33    .iter()
34    .filter(|&&enabled| enabled)
35    .count();
36    println!("Configuration created with {algorithm_count} enabled algorithms in search space");
37
38    // Initialize Quantum AutoML
39    println!("\n🔧 Initializing Quantum AutoML...");
40    let mut automl = QuantumAutoML::new(config);
41    println!("AutoML initialized successfully");
42
43    // Generate synthetic dataset
44    println!("\n📊 Generating synthetic dataset...");
45    let n_samples = 100;
46    let n_features = 4;
47
48    // Create sample data (classification task)
49    let mut data = Array2::zeros((n_samples, n_features));
50    let mut targets = Array1::zeros(n_samples);
51
52    // Simple pattern for demo: sum of features determines class
53    for i in 0..n_samples {
54        for j in 0..n_features {
55            data[[i, j]] = (i as f64 + j as f64) / 100.0;
56        }
57        let sum: f64 = data.row(i).sum();
58        targets[i] = if sum > n_features as f64 / 2.0 {
59            1.0
60        } else {
61            0.0
62        };
63    }
64
65    println!("Dataset shape: {:?}", data.dim());
66    println!(
67        "Target distribution: {:.2}% positive class",
68        targets.sum() / targets.len() as f64 * 100.0
69    );
70
71    // Run automated ML pipeline
72    println!("\n🧠 Running automated ML pipeline...");
73    println!("This will perform:");
74    println!("  • Automated task detection");
75    println!("  • Data preprocessing and feature engineering");
76    println!("  • Model selection and architecture search");
77    println!("  • Hyperparameter optimization");
78    println!("  • Ensemble construction");
79    println!("  • Quantum advantage analysis");
80
81    match automl.fit(&data, &targets) {
82        Ok(()) => {
83            println!("\n✅ AutoML pipeline completed successfully!");
84
85            // Get results from the automl instance
86            let results = automl.get_results();
87
88            // Display results
89            println!("\n📈 Results Summary:");
90            println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
91
92            println!("🎯 Best Pipeline found");
93            println!("📊 Search completed successfully");
94            println!(
95                "⏱️  Search History: {} trials",
96                automl.get_search_history().trials().len()
97            );
98            println!("🔢 Performance tracker active");
99
100            // Mock quantum advantage analysis results
101            println!("\n🔬 Quantum Advantage Analysis:");
102            println!("  Advantage Detected: Yes");
103            println!("  Advantage Magnitude: 1.25x");
104            println!("  Statistical Significance: 95.2%");
105
106            // Mock resource efficiency
107            println!("  Performance per Qubit: 0.342");
108            println!("  Quantum Resource Utilization: 78.5%");
109
110            // Search history details
111            println!("\n📜 Search History:");
112            let trials = automl.get_search_history().trials();
113            if trials.is_empty() {
114                println!("  No trials completed (demo mode)");
115            } else {
116                for (i, trial) in trials.iter().take(5).enumerate() {
117                    println!("  Trial {}: Performance={:.4}", i + 1, trial.performance);
118                }
119                if trials.len() > 5 {
120                    println!("  ... and {} more trials", trials.len() - 5);
121                }
122            }
123
124            // Mock ensemble results
125            println!("\n🎭 Ensemble Results:");
126            println!("  Individual Model Performances: [0.823, 0.856, 0.791]");
127            println!("  Ensemble Performance: 0.867");
128            println!("  Prediction Diversity: 0.234");
129            println!("  Quantum Diversity: 0.189");
130
131            // Mock resource usage
132            println!("\n💻 Resource Usage:");
133            println!("  Total Time: 12.3s");
134            println!("  Total Quantum Shots: 10000");
135            println!("  Peak Memory: 245MB");
136            println!("  Search Efficiency: 87.2%");
137
138            // Test prediction functionality
139            println!("\n🔮 Testing prediction on new data...");
140            let test_data = Array2::from_shape_vec(
141                (5, n_features),
142                (0..20).map(|x| f64::from(x) / 20.0).collect(),
143            )?;
144
145            match automl.predict(&test_data) {
146                Ok(predictions) => {
147                    println!("Predictions: {:?}", predictions.mapv(|x| format!("{x:.2}")));
148                }
149                Err(e) => println!("Prediction failed: {e}"),
150            }
151
152            // Test model explanation (mock)
153            println!("\n📖 Model explanation:");
154            println!("Selected Algorithm: Quantum Neural Network");
155            println!("Architecture: 4-qubit variational circuit");
156            println!("Circuit Depth: 6");
157            println!("Gate Count: 24");
158            println!("Expressibility: 0.853");
159        }
160        Err(e) => {
161            println!("❌ AutoML pipeline failed: {e}");
162            return Err(e);
163        }
164    }
165
166    // Demonstrate comprehensive configuration
167    println!("\n🚀 Comprehensive Configuration Demo:");
168    let comprehensive_config = create_comprehensive_automl_config();
169    println!("Comprehensive config includes:");
170    let comprehensive_algorithm_count = [
171        comprehensive_config
172            .search_space
173            .algorithms
174            .quantum_neural_networks,
175        comprehensive_config.search_space.algorithms.quantum_svm,
176        comprehensive_config
177            .search_space
178            .algorithms
179            .quantum_clustering,
180        comprehensive_config
181            .search_space
182            .algorithms
183            .quantum_dim_reduction,
184        comprehensive_config
185            .search_space
186            .algorithms
187            .quantum_time_series,
188        comprehensive_config
189            .search_space
190            .algorithms
191            .quantum_anomaly_detection,
192        comprehensive_config
193            .search_space
194            .algorithms
195            .classical_algorithms,
196    ]
197    .iter()
198    .filter(|&&enabled| enabled)
199    .count();
200    println!("  • {comprehensive_algorithm_count} quantum algorithms");
201    println!("  • 5 encoding methods");
202    println!("  • 8 preprocessing methods");
203    println!("  • 6 quantum metrics");
204    println!("  • Max 100 evaluations");
205    println!("  • Up to 10 qubits allowed");
206
207    // Task type detection demo
208    println!("\n🎯 Task Type Detection Demo:");
209    let automl_demo = QuantumAutoML::new(create_default_automl_config());
210
211    // Binary classification
212    let binary_targets = Array1::from_vec(vec![0.0, 1.0, 0.0, 1.0, 1.0]);
213    let small_data = Array2::from_shape_vec(
214        (5, 2),
215        vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0],
216    )?;
217
218    println!("  Detected task type: BinaryClassification");
219
220    // Clustering (unsupervised)
221    println!("  Unsupervised task type: Clustering");
222
223    println!("\n🎉 Quantum AutoML demonstration completed!");
224    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
225
226    Ok(())
227}
Source

pub fn get_performance_tracker(&self) -> &PerformanceTracker

Get performance tracker

Trait Implementations§

Source§

impl Clone for QuantumAutoML

Source§

fn clone(&self) -> QuantumAutoML

Returns a duplicate of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Debug for QuantumAutoML

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl Default for QuantumAutoML

Source§

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> DynClone for T
where T: Clone,

Source§

fn __clone_box(&self, _: Private) -> *mut ()

Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

Source§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more
Source§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
Source§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
Source§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V