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

pub fn get_search_history(&self) -> &SearchHistory

Get search history

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