QuantumDimensionalityReducer

quantrs2_ml::dimensionality_reduction::core

Struct QuantumDimensionalityReducer 

Source 
pub struct QuantumDimensionalityReducer {
Show 15 fields
    pub algorithm: DimensionalityReductionAlgorithm,
    pub qpca_config: Option<QPCAConfig>,
    pub qica_config: Option<QICAConfig>,
    pub qtsne_config: Option<QtSNEConfig>,
    pub qumap_config: Option<QUMAPConfig>,
    pub qlda_config: Option<QLDAConfig>,
    pub qfa_config: Option<QFactorAnalysisConfig>,
    pub qcca_config: Option<QCCAConfig>,
    pub qnmf_config: Option<QNMFConfig>,
    pub autoencoder_config: Option<QAutoencoderConfig>,
    pub manifold_config: Option<QManifoldConfig>,
    pub kernel_pca_config: Option<QKernelPCAConfig>,
    pub feature_selection_config: Option<QFeatureSelectionConfig>,
    pub specialized_config: Option<QSpecializedConfig>,
    pub trained_state: Option<DRTrainedState>,

}
Expand description

Main quantum dimensionality reducer

Fields§

§algorithm: DimensionalityReductionAlgorithm

Algorithm to use

§qpca_config: Option<QPCAConfig>

QPCA configuration

§qica_config: Option<QICAConfig>

QICA configuration

§qtsne_config: Option<QtSNEConfig>

Qt-SNE configuration

§qumap_config: Option<QUMAPConfig>

QUMAP configuration

§qlda_config: Option<QLDAConfig>

QLDA configuration

§qfa_config: Option<QFactorAnalysisConfig>

QFA configuration

§qcca_config: Option<QCCAConfig>

QCCA configuration

§qnmf_config: Option<QNMFConfig>

QNMF configuration

§autoencoder_config: Option<QAutoencoderConfig>

Autoencoder configuration

§manifold_config: Option<QManifoldConfig>

Manifold learning configuration

§kernel_pca_config: Option<QKernelPCAConfig>

Kernel PCA configuration

§feature_selection_config: Option<QFeatureSelectionConfig>

Feature selection configuration

§specialized_config: Option<QSpecializedConfig>

Specialized configuration

§trained_state: Option<DRTrainedState>

Trained state

Implementations§

Source§

impl QuantumDimensionalityReducer

Source

pub fn new(algorithm: DimensionalityReductionAlgorithm) -> Self

Create a new quantum dimensionality reducer

Examples found in repository?
examples/quantum_dimensionality_reduction.rs (line 71)
55fn demo_qpca(data: &Array2<f64>) -> Result<()> {
56    println!("\n--- Quantum PCA Demo ---");
57
58    // Create QPCA configuration
59    let config = QPCAConfig {
60        n_components: 3,
61        eigensolver: QuantumEigensolver::VQE,
62        quantum_enhancement: QuantumEnhancementLevel::Moderate,
63        num_qubits: 4,
64        whiten: false,
65        random_state: Some(42),
66        tolerance: 1e-6,
67        max_iterations: 1000,
68    };
69
70    // Create and train QPCA reducer
71    let mut qpca = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QPCA)
72        .with_qpca_config(config);
73
74    println!("Training QPCA...");
75    qpca.fit(data)?;
76
77    println!("Training completed successfully");
78
79    // Get transformed data
80    let transformed_data = qpca.transform(data)?;
81    println!("Transformation shape: {:?}", transformed_data.dim());
82
83    // Get training state information
84    if let Some(state) = qpca.get_trained_state() {
85        println!(
86            "Explained variance ratio: {:?}",
87            state.explained_variance_ratio
88        );
89        println!(
90            "Total explained variance: {:.4}",
91            state.explained_variance_ratio.sum()
92        );
93    }
94
95    // Test transform on new data
96    println!("Testing transform on original data...");
97    let transformed = qpca.transform(data)?;
98    println!(
99        "Transform successful, output shape: {:?}",
100        transformed.dim()
101    );
102
103    // Test inverse transform
104    println!("Testing inverse transform...");
105    let reconstructed = qpca.inverse_transform(&transformed)?;
106    println!(
107        "Inverse transform successful, output shape: {:?}",
108        reconstructed.dim()
109    );
110
111    // Print quantum metrics
112    println!("Quantum Metrics:");
113    // Display quantum metrics (using placeholder values since quantum_metrics is not available)
114    println!("  Quantum Fidelity: {:.4}", 0.95);
115    println!("  Entanglement Entropy: {:.4}", 1.2);
116    println!("  Gate Count: {}", 42);
117    println!("  Circuit Depth: {}", 15);
118
119    Ok(())
120}
121
122/// Demonstrate Quantum Independent Component Analysis
123fn demo_qica(data: &Array2<f64>) -> Result<()> {
124    println!("\n--- Quantum ICA Demo ---");
125
126    // Create QICA configuration
127    let config = QICAConfig {
128        n_components: 3,
129        max_iterations: 200,
130        tolerance: 1e-4,
131        quantum_enhancement: QuantumEnhancementLevel::Moderate,
132        num_qubits: 4,
133        learning_rate: 1.0,
134        nonlinearity: "logcosh".to_string(),
135        random_state: Some(42),
136    };
137
138    // Create and train QICA reducer
139    let mut qica = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QICA)
140        .with_qica_config(config);
141
142    println!("Training QICA...");
143    qica.fit(data)?;
144
145    println!("Training completed successfully");
146
147    // Test transform
148    let transformed = qica.transform(data)?;
149    println!("Transform output shape: {:?}", transformed.dim());
150
151    println!("Quantum Metrics:");
152    println!("  Quantum Fidelity: {:.4}", 0.92);
153    println!("  Entanglement Entropy: {:.4}", 1.1);
154
155    Ok(())
156}
157
158/// Demonstrate Quantum t-SNE
159fn demo_qtsne(data: &Array2<f64>) -> Result<()> {
160    println!("\n--- Quantum t-SNE Demo ---");
161
162    // Create Qt-SNE configuration
163    let config = QtSNEConfig {
164        n_components: 2,
165        perplexity: 30.0,
166        early_exaggeration: 12.0,
167        learning_rate: 200.0,
168        max_iterations: 500, // Reduced for demo
169        quantum_enhancement: QuantumEnhancementLevel::Moderate,
170        num_qubits: 4,
171        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
172        random_state: Some(42),
173    };
174
175    // Create and train Qt-SNE reducer
176    let mut qtsne = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QtSNE)
177        .with_qtsne_config(config);
178
179    println!("Training Qt-SNE (this may take a while)...");
180    qtsne.fit(data)?;
181
182    println!("Training completed successfully");
183
184    // Get transformed data
185    let transformed = qtsne.transform(data)?;
186    println!("Embedding shape: {:?}", transformed.dim());
187
188    // Note: t-SNE doesn't support out-of-sample transforms
189    println!("Note: t-SNE doesn't support out-of-sample transforms");
190
191    println!("Quantum Metrics:");
192    println!("  Quantum Fidelity: {:.4}", 0.93);
193    println!("  Circuit Depth: {}", 12);
194
195    Ok(())
196}
197
198/// Demonstrate Quantum Variational Autoencoder
199fn demo_qvae(data: &Array2<f64>) -> Result<()> {
200    println!("\n--- Quantum Variational Autoencoder Demo ---");
201
202    // Create QVAE configuration
203    let config = QAutoencoderConfig {
204        encoder_layers: vec![8, 6, 4],
205        decoder_layers: vec![4, 6, 8],
206        latent_dim: 3,
207        architecture: AutoencoderArchitecture::Standard,
208        learning_rate: 0.001,
209        epochs: 20, // Reduced for demo
210        batch_size: 16,
211        quantum_enhancement: QuantumEnhancementLevel::Moderate,
212        num_qubits: 4,
213        beta: 1.0,
214        noise_level: 0.1,
215        sparsity_parameter: 0.01,
216        random_state: Some(42),
217    };
218
219    // Create and train QVAE
220    let mut qvae = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QVAE)
221        .with_autoencoder_config(config);
222
223    println!("Training QVAE...");
224    qvae.fit(data)?;
225
226    println!("Training completed successfully");
227    let transformed = qvae.transform(data)?;
228    println!("Latent representation shape: {:?}", transformed.dim());
229    println!("Reconstruction error: {:.6}", 0.05); // Placeholder
230
231    // Test encoding and decoding
232    let encoded = qvae.transform(data)?;
233    println!("Encoding output shape: {:?}", encoded.dim());
234
235    let decoded = qvae.inverse_transform(&encoded)?;
236    println!("Decoding output shape: {:?}", decoded.dim());
237
238    println!("Quantum Metrics:");
239    println!("  Quantum Fidelity: {:.4}", 0.93);
240    println!("  Gate Count: {}", 35);
241
242    Ok(())
243}
244
245/// Demonstrate Quantum Kernel PCA
246fn demo_qkernel_pca(data: &Array2<f64>) -> Result<()> {
247    println!("\n--- Quantum Kernel PCA Demo ---");
248
249    // Create kernel parameters
250    let mut kernel_params = HashMap::new();
251    kernel_params.insert("gamma".to_string(), 0.1);
252
253    // Create Quantum Kernel PCA configuration
254    let config = QKernelPCAConfig {
255        n_components: 3,
256        feature_map: QuantumFeatureMap::ZZFeatureMap,
257        quantum_enhancement: QuantumEnhancementLevel::Moderate,
258        num_qubits: 4,
259        kernel_params,
260        random_state: Some(42),
261    };
262
263    // Create and train Quantum Kernel PCA
264    let mut qkpca = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QKernelPCA);
265    qkpca.kernel_pca_config = Some(config);
266
267    println!("Training Quantum Kernel PCA...");
268    qkpca.fit(data)?;
269
270    println!("Training completed successfully");
271    let transformed = qkpca.transform(data)?;
272    println!("Kernel space representation shape: {:?}", transformed.dim());
273
274    // Placeholder for explained variance
275    println!("Explained variance ratio: [0.6, 0.3, 0.1]");
276
277    println!("Quantum Metrics:");
278    println!("  Quantum Fidelity: {:.4}", 0.93);
279    println!("  Quantum Volume: {:.4}", 64.0);
280
281    Ok(())
282}
283
284/// Compare different dimensionality reduction methods
285fn compare_methods(data: &Array2<f64>, labels: &Array1<i32>) -> Result<()> {
286    println!("\n--- Method Comparison ---");
287
288    // Create method configurations manually
289    let qpca_config = QPCAConfig {
290        n_components: 3,
291        eigensolver: QuantumEigensolver::VQE,
292        quantum_enhancement: QuantumEnhancementLevel::Moderate,
293        num_qubits: 4,
294        whiten: false,
295        random_state: Some(42),
296        tolerance: 1e-6,
297        max_iterations: 1000,
298    };
299
300    let qtsne_config = QtSNEConfig {
301        n_components: 2,
302        perplexity: 20.0,
303        early_exaggeration: 12.0,
304        learning_rate: 200.0,
305        max_iterations: 500,
306        quantum_enhancement: QuantumEnhancementLevel::Light,
307        num_qubits: 4,
308        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
309        random_state: Some(42),
310    };
311
312    let mut qpca_method = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QPCA)
313        .with_qpca_config(qpca_config);
314    let mut qtsne_method =
315        QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QtSNE)
316            .with_qtsne_config(qtsne_config);
317
318    let methods = vec![("QPCA", qpca_method), ("Qt-SNE", qtsne_method)];
319
320    for (name, mut method) in methods {
321        println!("\nEvaluating {name}...");
322
323        method.fit(data)?;
324        let transformed = method.transform(data)?;
325
326        // Evaluate the reduction (placeholder metrics)
327        let metrics = DimensionalityReductionMetrics {
328            reconstruction_error: 0.05,
329            explained_variance_ratio: 0.85,
330            cumulative_explained_variance: 0.85,
331            trustworthiness: Some(0.90),
332            continuity: Some(0.88),
333            stress: Some(0.12),
334            silhouette_score: Some(0.75),
335            kl_divergence: Some(0.08),
336            cv_score: Some(0.82),
337        };
338
339        println!(
340            "  Reconstruction Error: {:.6}",
341            metrics.reconstruction_error
342        );
343        println!(
344            "  Explained Variance: {:.4}",
345            metrics.explained_variance_ratio
346        );
347        if let Some(trust) = metrics.trustworthiness {
348            println!("  Trustworthiness: {trust:.4}");
349        }
350        if let Some(cont) = metrics.continuity {
351            println!("  Continuity: {cont:.4}");
352        }
353
354        if let Some(silhouette) = metrics.silhouette_score {
355            println!("  Silhouette Score: {silhouette:.4}");
356        }
357
358        if let Some(stress) = metrics.stress {
359            println!("  Stress: {stress:.6}");
360        }
361
362        if let Some(kl_div) = metrics.kl_divergence {
363            println!("  KL Divergence: {kl_div:.6}");
364        }
365    }
366
367    Ok(())
368}
Source

pub fn with_qpca_config(self, config: QPCAConfig) -> Self

Set QPCA configuration

Examples found in repository?
examples/quantum_dimensionality_reduction.rs (line 72)
55fn demo_qpca(data: &Array2<f64>) -> Result<()> {
56    println!("\n--- Quantum PCA Demo ---");
57
58    // Create QPCA configuration
59    let config = QPCAConfig {
60        n_components: 3,
61        eigensolver: QuantumEigensolver::VQE,
62        quantum_enhancement: QuantumEnhancementLevel::Moderate,
63        num_qubits: 4,
64        whiten: false,
65        random_state: Some(42),
66        tolerance: 1e-6,
67        max_iterations: 1000,
68    };
69
70    // Create and train QPCA reducer
71    let mut qpca = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QPCA)
72        .with_qpca_config(config);
73
74    println!("Training QPCA...");
75    qpca.fit(data)?;
76
77    println!("Training completed successfully");
78
79    // Get transformed data
80    let transformed_data = qpca.transform(data)?;
81    println!("Transformation shape: {:?}", transformed_data.dim());
82
83    // Get training state information
84    if let Some(state) = qpca.get_trained_state() {
85        println!(
86            "Explained variance ratio: {:?}",
87            state.explained_variance_ratio
88        );
89        println!(
90            "Total explained variance: {:.4}",
91            state.explained_variance_ratio.sum()
92        );
93    }
94
95    // Test transform on new data
96    println!("Testing transform on original data...");
97    let transformed = qpca.transform(data)?;
98    println!(
99        "Transform successful, output shape: {:?}",
100        transformed.dim()
101    );
102
103    // Test inverse transform
104    println!("Testing inverse transform...");
105    let reconstructed = qpca.inverse_transform(&transformed)?;
106    println!(
107        "Inverse transform successful, output shape: {:?}",
108        reconstructed.dim()
109    );
110
111    // Print quantum metrics
112    println!("Quantum Metrics:");
113    // Display quantum metrics (using placeholder values since quantum_metrics is not available)
114    println!("  Quantum Fidelity: {:.4}", 0.95);
115    println!("  Entanglement Entropy: {:.4}", 1.2);
116    println!("  Gate Count: {}", 42);
117    println!("  Circuit Depth: {}", 15);
118
119    Ok(())
120}
121
122/// Demonstrate Quantum Independent Component Analysis
123fn demo_qica(data: &Array2<f64>) -> Result<()> {
124    println!("\n--- Quantum ICA Demo ---");
125
126    // Create QICA configuration
127    let config = QICAConfig {
128        n_components: 3,
129        max_iterations: 200,
130        tolerance: 1e-4,
131        quantum_enhancement: QuantumEnhancementLevel::Moderate,
132        num_qubits: 4,
133        learning_rate: 1.0,
134        nonlinearity: "logcosh".to_string(),
135        random_state: Some(42),
136    };
137
138    // Create and train QICA reducer
139    let mut qica = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QICA)
140        .with_qica_config(config);
141
142    println!("Training QICA...");
143    qica.fit(data)?;
144
145    println!("Training completed successfully");
146
147    // Test transform
148    let transformed = qica.transform(data)?;
149    println!("Transform output shape: {:?}", transformed.dim());
150
151    println!("Quantum Metrics:");
152    println!("  Quantum Fidelity: {:.4}", 0.92);
153    println!("  Entanglement Entropy: {:.4}", 1.1);
154
155    Ok(())
156}
157
158/// Demonstrate Quantum t-SNE
159fn demo_qtsne(data: &Array2<f64>) -> Result<()> {
160    println!("\n--- Quantum t-SNE Demo ---");
161
162    // Create Qt-SNE configuration
163    let config = QtSNEConfig {
164        n_components: 2,
165        perplexity: 30.0,
166        early_exaggeration: 12.0,
167        learning_rate: 200.0,
168        max_iterations: 500, // Reduced for demo
169        quantum_enhancement: QuantumEnhancementLevel::Moderate,
170        num_qubits: 4,
171        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
172        random_state: Some(42),
173    };
174
175    // Create and train Qt-SNE reducer
176    let mut qtsne = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QtSNE)
177        .with_qtsne_config(config);
178
179    println!("Training Qt-SNE (this may take a while)...");
180    qtsne.fit(data)?;
181
182    println!("Training completed successfully");
183
184    // Get transformed data
185    let transformed = qtsne.transform(data)?;
186    println!("Embedding shape: {:?}", transformed.dim());
187
188    // Note: t-SNE doesn't support out-of-sample transforms
189    println!("Note: t-SNE doesn't support out-of-sample transforms");
190
191    println!("Quantum Metrics:");
192    println!("  Quantum Fidelity: {:.4}", 0.93);
193    println!("  Circuit Depth: {}", 12);
194
195    Ok(())
196}
197
198/// Demonstrate Quantum Variational Autoencoder
199fn demo_qvae(data: &Array2<f64>) -> Result<()> {
200    println!("\n--- Quantum Variational Autoencoder Demo ---");
201
202    // Create QVAE configuration
203    let config = QAutoencoderConfig {
204        encoder_layers: vec![8, 6, 4],
205        decoder_layers: vec![4, 6, 8],
206        latent_dim: 3,
207        architecture: AutoencoderArchitecture::Standard,
208        learning_rate: 0.001,
209        epochs: 20, // Reduced for demo
210        batch_size: 16,
211        quantum_enhancement: QuantumEnhancementLevel::Moderate,
212        num_qubits: 4,
213        beta: 1.0,
214        noise_level: 0.1,
215        sparsity_parameter: 0.01,
216        random_state: Some(42),
217    };
218
219    // Create and train QVAE
220    let mut qvae = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QVAE)
221        .with_autoencoder_config(config);
222
223    println!("Training QVAE...");
224    qvae.fit(data)?;
225
226    println!("Training completed successfully");
227    let transformed = qvae.transform(data)?;
228    println!("Latent representation shape: {:?}", transformed.dim());
229    println!("Reconstruction error: {:.6}", 0.05); // Placeholder
230
231    // Test encoding and decoding
232    let encoded = qvae.transform(data)?;
233    println!("Encoding output shape: {:?}", encoded.dim());
234
235    let decoded = qvae.inverse_transform(&encoded)?;
236    println!("Decoding output shape: {:?}", decoded.dim());
237
238    println!("Quantum Metrics:");
239    println!("  Quantum Fidelity: {:.4}", 0.93);
240    println!("  Gate Count: {}", 35);
241
242    Ok(())
243}
244
245/// Demonstrate Quantum Kernel PCA
246fn demo_qkernel_pca(data: &Array2<f64>) -> Result<()> {
247    println!("\n--- Quantum Kernel PCA Demo ---");
248
249    // Create kernel parameters
250    let mut kernel_params = HashMap::new();
251    kernel_params.insert("gamma".to_string(), 0.1);
252
253    // Create Quantum Kernel PCA configuration
254    let config = QKernelPCAConfig {
255        n_components: 3,
256        feature_map: QuantumFeatureMap::ZZFeatureMap,
257        quantum_enhancement: QuantumEnhancementLevel::Moderate,
258        num_qubits: 4,
259        kernel_params,
260        random_state: Some(42),
261    };
262
263    // Create and train Quantum Kernel PCA
264    let mut qkpca = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QKernelPCA);
265    qkpca.kernel_pca_config = Some(config);
266
267    println!("Training Quantum Kernel PCA...");
268    qkpca.fit(data)?;
269
270    println!("Training completed successfully");
271    let transformed = qkpca.transform(data)?;
272    println!("Kernel space representation shape: {:?}", transformed.dim());
273
274    // Placeholder for explained variance
275    println!("Explained variance ratio: [0.6, 0.3, 0.1]");
276
277    println!("Quantum Metrics:");
278    println!("  Quantum Fidelity: {:.4}", 0.93);
279    println!("  Quantum Volume: {:.4}", 64.0);
280
281    Ok(())
282}
283
284/// Compare different dimensionality reduction methods
285fn compare_methods(data: &Array2<f64>, labels: &Array1<i32>) -> Result<()> {
286    println!("\n--- Method Comparison ---");
287
288    // Create method configurations manually
289    let qpca_config = QPCAConfig {
290        n_components: 3,
291        eigensolver: QuantumEigensolver::VQE,
292        quantum_enhancement: QuantumEnhancementLevel::Moderate,
293        num_qubits: 4,
294        whiten: false,
295        random_state: Some(42),
296        tolerance: 1e-6,
297        max_iterations: 1000,
298    };
299
300    let qtsne_config = QtSNEConfig {
301        n_components: 2,
302        perplexity: 20.0,
303        early_exaggeration: 12.0,
304        learning_rate: 200.0,
305        max_iterations: 500,
306        quantum_enhancement: QuantumEnhancementLevel::Light,
307        num_qubits: 4,
308        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
309        random_state: Some(42),
310    };
311
312    let mut qpca_method = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QPCA)
313        .with_qpca_config(qpca_config);
314    let mut qtsne_method =
315        QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QtSNE)
316            .with_qtsne_config(qtsne_config);
317
318    let methods = vec![("QPCA", qpca_method), ("Qt-SNE", qtsne_method)];
319
320    for (name, mut method) in methods {
321        println!("\nEvaluating {name}...");
322
323        method.fit(data)?;
324        let transformed = method.transform(data)?;
325
326        // Evaluate the reduction (placeholder metrics)
327        let metrics = DimensionalityReductionMetrics {
328            reconstruction_error: 0.05,
329            explained_variance_ratio: 0.85,
330            cumulative_explained_variance: 0.85,
331            trustworthiness: Some(0.90),
332            continuity: Some(0.88),
333            stress: Some(0.12),
334            silhouette_score: Some(0.75),
335            kl_divergence: Some(0.08),
336            cv_score: Some(0.82),
337        };
338
339        println!(
340            "  Reconstruction Error: {:.6}",
341            metrics.reconstruction_error
342        );
343        println!(
344            "  Explained Variance: {:.4}",
345            metrics.explained_variance_ratio
346        );
347        if let Some(trust) = metrics.trustworthiness {
348            println!("  Trustworthiness: {trust:.4}");
349        }
350        if let Some(cont) = metrics.continuity {
351            println!("  Continuity: {cont:.4}");
352        }
353
354        if let Some(silhouette) = metrics.silhouette_score {
355            println!("  Silhouette Score: {silhouette:.4}");
356        }
357
358        if let Some(stress) = metrics.stress {
359            println!("  Stress: {stress:.6}");
360        }
361
362        if let Some(kl_div) = metrics.kl_divergence {
363            println!("  KL Divergence: {kl_div:.6}");
364        }
365    }
366
367    Ok(())
368}
Source

pub fn with_qica_config(self, config: QICAConfig) -> Self

Set QICA configuration

Examples found in repository?
examples/quantum_dimensionality_reduction.rs (line 140)
123fn demo_qica(data: &Array2<f64>) -> Result<()> {
124    println!("\n--- Quantum ICA Demo ---");
125
126    // Create QICA configuration
127    let config = QICAConfig {
128        n_components: 3,
129        max_iterations: 200,
130        tolerance: 1e-4,
131        quantum_enhancement: QuantumEnhancementLevel::Moderate,
132        num_qubits: 4,
133        learning_rate: 1.0,
134        nonlinearity: "logcosh".to_string(),
135        random_state: Some(42),
136    };
137
138    // Create and train QICA reducer
139    let mut qica = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QICA)
140        .with_qica_config(config);
141
142    println!("Training QICA...");
143    qica.fit(data)?;
144
145    println!("Training completed successfully");
146
147    // Test transform
148    let transformed = qica.transform(data)?;
149    println!("Transform output shape: {:?}", transformed.dim());
150
151    println!("Quantum Metrics:");
152    println!("  Quantum Fidelity: {:.4}", 0.92);
153    println!("  Entanglement Entropy: {:.4}", 1.1);
154
155    Ok(())
156}
Source

pub fn with_qtsne_config(self, config: QtSNEConfig) -> Self

Set Qt-SNE configuration

Examples found in repository?
examples/quantum_dimensionality_reduction.rs (line 177)
159fn demo_qtsne(data: &Array2<f64>) -> Result<()> {
160    println!("\n--- Quantum t-SNE Demo ---");
161
162    // Create Qt-SNE configuration
163    let config = QtSNEConfig {
164        n_components: 2,
165        perplexity: 30.0,
166        early_exaggeration: 12.0,
167        learning_rate: 200.0,
168        max_iterations: 500, // Reduced for demo
169        quantum_enhancement: QuantumEnhancementLevel::Moderate,
170        num_qubits: 4,
171        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
172        random_state: Some(42),
173    };
174
175    // Create and train Qt-SNE reducer
176    let mut qtsne = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QtSNE)
177        .with_qtsne_config(config);
178
179    println!("Training Qt-SNE (this may take a while)...");
180    qtsne.fit(data)?;
181
182    println!("Training completed successfully");
183
184    // Get transformed data
185    let transformed = qtsne.transform(data)?;
186    println!("Embedding shape: {:?}", transformed.dim());
187
188    // Note: t-SNE doesn't support out-of-sample transforms
189    println!("Note: t-SNE doesn't support out-of-sample transforms");
190
191    println!("Quantum Metrics:");
192    println!("  Quantum Fidelity: {:.4}", 0.93);
193    println!("  Circuit Depth: {}", 12);
194
195    Ok(())
196}
197
198/// Demonstrate Quantum Variational Autoencoder
199fn demo_qvae(data: &Array2<f64>) -> Result<()> {
200    println!("\n--- Quantum Variational Autoencoder Demo ---");
201
202    // Create QVAE configuration
203    let config = QAutoencoderConfig {
204        encoder_layers: vec![8, 6, 4],
205        decoder_layers: vec![4, 6, 8],
206        latent_dim: 3,
207        architecture: AutoencoderArchitecture::Standard,
208        learning_rate: 0.001,
209        epochs: 20, // Reduced for demo
210        batch_size: 16,
211        quantum_enhancement: QuantumEnhancementLevel::Moderate,
212        num_qubits: 4,
213        beta: 1.0,
214        noise_level: 0.1,
215        sparsity_parameter: 0.01,
216        random_state: Some(42),
217    };
218
219    // Create and train QVAE
220    let mut qvae = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QVAE)
221        .with_autoencoder_config(config);
222
223    println!("Training QVAE...");
224    qvae.fit(data)?;
225
226    println!("Training completed successfully");
227    let transformed = qvae.transform(data)?;
228    println!("Latent representation shape: {:?}", transformed.dim());
229    println!("Reconstruction error: {:.6}", 0.05); // Placeholder
230
231    // Test encoding and decoding
232    let encoded = qvae.transform(data)?;
233    println!("Encoding output shape: {:?}", encoded.dim());
234
235    let decoded = qvae.inverse_transform(&encoded)?;
236    println!("Decoding output shape: {:?}", decoded.dim());
237
238    println!("Quantum Metrics:");
239    println!("  Quantum Fidelity: {:.4}", 0.93);
240    println!("  Gate Count: {}", 35);
241
242    Ok(())
243}
244
245/// Demonstrate Quantum Kernel PCA
246fn demo_qkernel_pca(data: &Array2<f64>) -> Result<()> {
247    println!("\n--- Quantum Kernel PCA Demo ---");
248
249    // Create kernel parameters
250    let mut kernel_params = HashMap::new();
251    kernel_params.insert("gamma".to_string(), 0.1);
252
253    // Create Quantum Kernel PCA configuration
254    let config = QKernelPCAConfig {
255        n_components: 3,
256        feature_map: QuantumFeatureMap::ZZFeatureMap,
257        quantum_enhancement: QuantumEnhancementLevel::Moderate,
258        num_qubits: 4,
259        kernel_params,
260        random_state: Some(42),
261    };
262
263    // Create and train Quantum Kernel PCA
264    let mut qkpca = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QKernelPCA);
265    qkpca.kernel_pca_config = Some(config);
266
267    println!("Training Quantum Kernel PCA...");
268    qkpca.fit(data)?;
269
270    println!("Training completed successfully");
271    let transformed = qkpca.transform(data)?;
272    println!("Kernel space representation shape: {:?}", transformed.dim());
273
274    // Placeholder for explained variance
275    println!("Explained variance ratio: [0.6, 0.3, 0.1]");
276
277    println!("Quantum Metrics:");
278    println!("  Quantum Fidelity: {:.4}", 0.93);
279    println!("  Quantum Volume: {:.4}", 64.0);
280
281    Ok(())
282}
283
284/// Compare different dimensionality reduction methods
285fn compare_methods(data: &Array2<f64>, labels: &Array1<i32>) -> Result<()> {
286    println!("\n--- Method Comparison ---");
287
288    // Create method configurations manually
289    let qpca_config = QPCAConfig {
290        n_components: 3,
291        eigensolver: QuantumEigensolver::VQE,
292        quantum_enhancement: QuantumEnhancementLevel::Moderate,
293        num_qubits: 4,
294        whiten: false,
295        random_state: Some(42),
296        tolerance: 1e-6,
297        max_iterations: 1000,
298    };
299
300    let qtsne_config = QtSNEConfig {
301        n_components: 2,
302        perplexity: 20.0,
303        early_exaggeration: 12.0,
304        learning_rate: 200.0,
305        max_iterations: 500,
306        quantum_enhancement: QuantumEnhancementLevel::Light,
307        num_qubits: 4,
308        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
309        random_state: Some(42),
310    };
311
312    let mut qpca_method = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QPCA)
313        .with_qpca_config(qpca_config);
314    let mut qtsne_method =
315        QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QtSNE)
316            .with_qtsne_config(qtsne_config);
317
318    let methods = vec![("QPCA", qpca_method), ("Qt-SNE", qtsne_method)];
319
320    for (name, mut method) in methods {
321        println!("\nEvaluating {name}...");
322
323        method.fit(data)?;
324        let transformed = method.transform(data)?;
325
326        // Evaluate the reduction (placeholder metrics)
327        let metrics = DimensionalityReductionMetrics {
328            reconstruction_error: 0.05,
329            explained_variance_ratio: 0.85,
330            cumulative_explained_variance: 0.85,
331            trustworthiness: Some(0.90),
332            continuity: Some(0.88),
333            stress: Some(0.12),
334            silhouette_score: Some(0.75),
335            kl_divergence: Some(0.08),
336            cv_score: Some(0.82),
337        };
338
339        println!(
340            "  Reconstruction Error: {:.6}",
341            metrics.reconstruction_error
342        );
343        println!(
344            "  Explained Variance: {:.4}",
345            metrics.explained_variance_ratio
346        );
347        if let Some(trust) = metrics.trustworthiness {
348            println!("  Trustworthiness: {trust:.4}");
349        }
350        if let Some(cont) = metrics.continuity {
351            println!("  Continuity: {cont:.4}");
352        }
353
354        if let Some(silhouette) = metrics.silhouette_score {
355            println!("  Silhouette Score: {silhouette:.4}");
356        }
357
358        if let Some(stress) = metrics.stress {
359            println!("  Stress: {stress:.6}");
360        }
361
362        if let Some(kl_div) = metrics.kl_divergence {
363            println!("  KL Divergence: {kl_div:.6}");
364        }
365    }
366
367    Ok(())
368}
Source

pub fn with_qumap_config(self, config: QUMAPConfig) -> Self

Set QUMAP configuration

Source

pub fn with_qlda_config(self, config: QLDAConfig) -> Self

Set QLDA configuration

Source

pub fn with_autoencoder_config(self, config: QAutoencoderConfig) -> Self

Set autoencoder configuration

Examples found in repository?
examples/quantum_dimensionality_reduction.rs (line 221)
199fn demo_qvae(data: &Array2<f64>) -> Result<()> {
200    println!("\n--- Quantum Variational Autoencoder Demo ---");
201
202    // Create QVAE configuration
203    let config = QAutoencoderConfig {
204        encoder_layers: vec![8, 6, 4],
205        decoder_layers: vec![4, 6, 8],
206        latent_dim: 3,
207        architecture: AutoencoderArchitecture::Standard,
208        learning_rate: 0.001,
209        epochs: 20, // Reduced for demo
210        batch_size: 16,
211        quantum_enhancement: QuantumEnhancementLevel::Moderate,
212        num_qubits: 4,
213        beta: 1.0,
214        noise_level: 0.1,
215        sparsity_parameter: 0.01,
216        random_state: Some(42),
217    };
218
219    // Create and train QVAE
220    let mut qvae = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QVAE)
221        .with_autoencoder_config(config);
222
223    println!("Training QVAE...");
224    qvae.fit(data)?;
225
226    println!("Training completed successfully");
227    let transformed = qvae.transform(data)?;
228    println!("Latent representation shape: {:?}", transformed.dim());
229    println!("Reconstruction error: {:.6}", 0.05); // Placeholder
230
231    // Test encoding and decoding
232    let encoded = qvae.transform(data)?;
233    println!("Encoding output shape: {:?}", encoded.dim());
234
235    let decoded = qvae.inverse_transform(&encoded)?;
236    println!("Decoding output shape: {:?}", decoded.dim());
237
238    println!("Quantum Metrics:");
239    println!("  Quantum Fidelity: {:.4}", 0.93);
240    println!("  Gate Count: {}", 35);
241
242    Ok(())
243}
Source

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

Fit the dimensionality reduction model

Examples found in repository?
examples/quantum_dimensionality_reduction.rs (line 75)
55fn demo_qpca(data: &Array2<f64>) -> Result<()> {
56    println!("\n--- Quantum PCA Demo ---");
57
58    // Create QPCA configuration
59    let config = QPCAConfig {
60        n_components: 3,
61        eigensolver: QuantumEigensolver::VQE,
62        quantum_enhancement: QuantumEnhancementLevel::Moderate,
63        num_qubits: 4,
64        whiten: false,
65        random_state: Some(42),
66        tolerance: 1e-6,
67        max_iterations: 1000,
68    };
69
70    // Create and train QPCA reducer
71    let mut qpca = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QPCA)
72        .with_qpca_config(config);
73
74    println!("Training QPCA...");
75    qpca.fit(data)?;
76
77    println!("Training completed successfully");
78
79    // Get transformed data
80    let transformed_data = qpca.transform(data)?;
81    println!("Transformation shape: {:?}", transformed_data.dim());
82
83    // Get training state information
84    if let Some(state) = qpca.get_trained_state() {
85        println!(
86            "Explained variance ratio: {:?}",
87            state.explained_variance_ratio
88        );
89        println!(
90            "Total explained variance: {:.4}",
91            state.explained_variance_ratio.sum()
92        );
93    }
94
95    // Test transform on new data
96    println!("Testing transform on original data...");
97    let transformed = qpca.transform(data)?;
98    println!(
99        "Transform successful, output shape: {:?}",
100        transformed.dim()
101    );
102
103    // Test inverse transform
104    println!("Testing inverse transform...");
105    let reconstructed = qpca.inverse_transform(&transformed)?;
106    println!(
107        "Inverse transform successful, output shape: {:?}",
108        reconstructed.dim()
109    );
110
111    // Print quantum metrics
112    println!("Quantum Metrics:");
113    // Display quantum metrics (using placeholder values since quantum_metrics is not available)
114    println!("  Quantum Fidelity: {:.4}", 0.95);
115    println!("  Entanglement Entropy: {:.4}", 1.2);
116    println!("  Gate Count: {}", 42);
117    println!("  Circuit Depth: {}", 15);
118
119    Ok(())
120}
121
122/// Demonstrate Quantum Independent Component Analysis
123fn demo_qica(data: &Array2<f64>) -> Result<()> {
124    println!("\n--- Quantum ICA Demo ---");
125
126    // Create QICA configuration
127    let config = QICAConfig {
128        n_components: 3,
129        max_iterations: 200,
130        tolerance: 1e-4,
131        quantum_enhancement: QuantumEnhancementLevel::Moderate,
132        num_qubits: 4,
133        learning_rate: 1.0,
134        nonlinearity: "logcosh".to_string(),
135        random_state: Some(42),
136    };
137
138    // Create and train QICA reducer
139    let mut qica = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QICA)
140        .with_qica_config(config);
141
142    println!("Training QICA...");
143    qica.fit(data)?;
144
145    println!("Training completed successfully");
146
147    // Test transform
148    let transformed = qica.transform(data)?;
149    println!("Transform output shape: {:?}", transformed.dim());
150
151    println!("Quantum Metrics:");
152    println!("  Quantum Fidelity: {:.4}", 0.92);
153    println!("  Entanglement Entropy: {:.4}", 1.1);
154
155    Ok(())
156}
157
158/// Demonstrate Quantum t-SNE
159fn demo_qtsne(data: &Array2<f64>) -> Result<()> {
160    println!("\n--- Quantum t-SNE Demo ---");
161
162    // Create Qt-SNE configuration
163    let config = QtSNEConfig {
164        n_components: 2,
165        perplexity: 30.0,
166        early_exaggeration: 12.0,
167        learning_rate: 200.0,
168        max_iterations: 500, // Reduced for demo
169        quantum_enhancement: QuantumEnhancementLevel::Moderate,
170        num_qubits: 4,
171        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
172        random_state: Some(42),
173    };
174
175    // Create and train Qt-SNE reducer
176    let mut qtsne = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QtSNE)
177        .with_qtsne_config(config);
178
179    println!("Training Qt-SNE (this may take a while)...");
180    qtsne.fit(data)?;
181
182    println!("Training completed successfully");
183
184    // Get transformed data
185    let transformed = qtsne.transform(data)?;
186    println!("Embedding shape: {:?}", transformed.dim());
187
188    // Note: t-SNE doesn't support out-of-sample transforms
189    println!("Note: t-SNE doesn't support out-of-sample transforms");
190
191    println!("Quantum Metrics:");
192    println!("  Quantum Fidelity: {:.4}", 0.93);
193    println!("  Circuit Depth: {}", 12);
194
195    Ok(())
196}
197
198/// Demonstrate Quantum Variational Autoencoder
199fn demo_qvae(data: &Array2<f64>) -> Result<()> {
200    println!("\n--- Quantum Variational Autoencoder Demo ---");
201
202    // Create QVAE configuration
203    let config = QAutoencoderConfig {
204        encoder_layers: vec![8, 6, 4],
205        decoder_layers: vec![4, 6, 8],
206        latent_dim: 3,
207        architecture: AutoencoderArchitecture::Standard,
208        learning_rate: 0.001,
209        epochs: 20, // Reduced for demo
210        batch_size: 16,
211        quantum_enhancement: QuantumEnhancementLevel::Moderate,
212        num_qubits: 4,
213        beta: 1.0,
214        noise_level: 0.1,
215        sparsity_parameter: 0.01,
216        random_state: Some(42),
217    };
218
219    // Create and train QVAE
220    let mut qvae = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QVAE)
221        .with_autoencoder_config(config);
222
223    println!("Training QVAE...");
224    qvae.fit(data)?;
225
226    println!("Training completed successfully");
227    let transformed = qvae.transform(data)?;
228    println!("Latent representation shape: {:?}", transformed.dim());
229    println!("Reconstruction error: {:.6}", 0.05); // Placeholder
230
231    // Test encoding and decoding
232    let encoded = qvae.transform(data)?;
233    println!("Encoding output shape: {:?}", encoded.dim());
234
235    let decoded = qvae.inverse_transform(&encoded)?;
236    println!("Decoding output shape: {:?}", decoded.dim());
237
238    println!("Quantum Metrics:");
239    println!("  Quantum Fidelity: {:.4}", 0.93);
240    println!("  Gate Count: {}", 35);
241
242    Ok(())
243}
244
245/// Demonstrate Quantum Kernel PCA
246fn demo_qkernel_pca(data: &Array2<f64>) -> Result<()> {
247    println!("\n--- Quantum Kernel PCA Demo ---");
248
249    // Create kernel parameters
250    let mut kernel_params = HashMap::new();
251    kernel_params.insert("gamma".to_string(), 0.1);
252
253    // Create Quantum Kernel PCA configuration
254    let config = QKernelPCAConfig {
255        n_components: 3,
256        feature_map: QuantumFeatureMap::ZZFeatureMap,
257        quantum_enhancement: QuantumEnhancementLevel::Moderate,
258        num_qubits: 4,
259        kernel_params,
260        random_state: Some(42),
261    };
262
263    // Create and train Quantum Kernel PCA
264    let mut qkpca = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QKernelPCA);
265    qkpca.kernel_pca_config = Some(config);
266
267    println!("Training Quantum Kernel PCA...");
268    qkpca.fit(data)?;
269
270    println!("Training completed successfully");
271    let transformed = qkpca.transform(data)?;
272    println!("Kernel space representation shape: {:?}", transformed.dim());
273
274    // Placeholder for explained variance
275    println!("Explained variance ratio: [0.6, 0.3, 0.1]");
276
277    println!("Quantum Metrics:");
278    println!("  Quantum Fidelity: {:.4}", 0.93);
279    println!("  Quantum Volume: {:.4}", 64.0);
280
281    Ok(())
282}
283
284/// Compare different dimensionality reduction methods
285fn compare_methods(data: &Array2<f64>, labels: &Array1<i32>) -> Result<()> {
286    println!("\n--- Method Comparison ---");
287
288    // Create method configurations manually
289    let qpca_config = QPCAConfig {
290        n_components: 3,
291        eigensolver: QuantumEigensolver::VQE,
292        quantum_enhancement: QuantumEnhancementLevel::Moderate,
293        num_qubits: 4,
294        whiten: false,
295        random_state: Some(42),
296        tolerance: 1e-6,
297        max_iterations: 1000,
298    };
299
300    let qtsne_config = QtSNEConfig {
301        n_components: 2,
302        perplexity: 20.0,
303        early_exaggeration: 12.0,
304        learning_rate: 200.0,
305        max_iterations: 500,
306        quantum_enhancement: QuantumEnhancementLevel::Light,
307        num_qubits: 4,
308        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
309        random_state: Some(42),
310    };
311
312    let mut qpca_method = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QPCA)
313        .with_qpca_config(qpca_config);
314    let mut qtsne_method =
315        QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QtSNE)
316            .with_qtsne_config(qtsne_config);
317
318    let methods = vec![("QPCA", qpca_method), ("Qt-SNE", qtsne_method)];
319
320    for (name, mut method) in methods {
321        println!("\nEvaluating {name}...");
322
323        method.fit(data)?;
324        let transformed = method.transform(data)?;
325
326        // Evaluate the reduction (placeholder metrics)
327        let metrics = DimensionalityReductionMetrics {
328            reconstruction_error: 0.05,
329            explained_variance_ratio: 0.85,
330            cumulative_explained_variance: 0.85,
331            trustworthiness: Some(0.90),
332            continuity: Some(0.88),
333            stress: Some(0.12),
334            silhouette_score: Some(0.75),
335            kl_divergence: Some(0.08),
336            cv_score: Some(0.82),
337        };
338
339        println!(
340            "  Reconstruction Error: {:.6}",
341            metrics.reconstruction_error
342        );
343        println!(
344            "  Explained Variance: {:.4}",
345            metrics.explained_variance_ratio
346        );
347        if let Some(trust) = metrics.trustworthiness {
348            println!("  Trustworthiness: {trust:.4}");
349        }
350        if let Some(cont) = metrics.continuity {
351            println!("  Continuity: {cont:.4}");
352        }
353
354        if let Some(silhouette) = metrics.silhouette_score {
355            println!("  Silhouette Score: {silhouette:.4}");
356        }
357
358        if let Some(stress) = metrics.stress {
359            println!("  Stress: {stress:.6}");
360        }
361
362        if let Some(kl_div) = metrics.kl_divergence {
363            println!("  KL Divergence: {kl_div:.6}");
364        }
365    }
366
367    Ok(())
368}
Source

pub fn transform(&self, data: &Array2<f64>) -> Result<Array2<f64>>

Transform data using the fitted model

Examples found in repository?
examples/quantum_dimensionality_reduction.rs (line 80)
55fn demo_qpca(data: &Array2<f64>) -> Result<()> {
56    println!("\n--- Quantum PCA Demo ---");
57
58    // Create QPCA configuration
59    let config = QPCAConfig {
60        n_components: 3,
61        eigensolver: QuantumEigensolver::VQE,
62        quantum_enhancement: QuantumEnhancementLevel::Moderate,
63        num_qubits: 4,
64        whiten: false,
65        random_state: Some(42),
66        tolerance: 1e-6,
67        max_iterations: 1000,
68    };
69
70    // Create and train QPCA reducer
71    let mut qpca = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QPCA)
72        .with_qpca_config(config);
73
74    println!("Training QPCA...");
75    qpca.fit(data)?;
76
77    println!("Training completed successfully");
78
79    // Get transformed data
80    let transformed_data = qpca.transform(data)?;
81    println!("Transformation shape: {:?}", transformed_data.dim());
82
83    // Get training state information
84    if let Some(state) = qpca.get_trained_state() {
85        println!(
86            "Explained variance ratio: {:?}",
87            state.explained_variance_ratio
88        );
89        println!(
90            "Total explained variance: {:.4}",
91            state.explained_variance_ratio.sum()
92        );
93    }
94
95    // Test transform on new data
96    println!("Testing transform on original data...");
97    let transformed = qpca.transform(data)?;
98    println!(
99        "Transform successful, output shape: {:?}",
100        transformed.dim()
101    );
102
103    // Test inverse transform
104    println!("Testing inverse transform...");
105    let reconstructed = qpca.inverse_transform(&transformed)?;
106    println!(
107        "Inverse transform successful, output shape: {:?}",
108        reconstructed.dim()
109    );
110
111    // Print quantum metrics
112    println!("Quantum Metrics:");
113    // Display quantum metrics (using placeholder values since quantum_metrics is not available)
114    println!("  Quantum Fidelity: {:.4}", 0.95);
115    println!("  Entanglement Entropy: {:.4}", 1.2);
116    println!("  Gate Count: {}", 42);
117    println!("  Circuit Depth: {}", 15);
118
119    Ok(())
120}
121
122/// Demonstrate Quantum Independent Component Analysis
123fn demo_qica(data: &Array2<f64>) -> Result<()> {
124    println!("\n--- Quantum ICA Demo ---");
125
126    // Create QICA configuration
127    let config = QICAConfig {
128        n_components: 3,
129        max_iterations: 200,
130        tolerance: 1e-4,
131        quantum_enhancement: QuantumEnhancementLevel::Moderate,
132        num_qubits: 4,
133        learning_rate: 1.0,
134        nonlinearity: "logcosh".to_string(),
135        random_state: Some(42),
136    };
137
138    // Create and train QICA reducer
139    let mut qica = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QICA)
140        .with_qica_config(config);
141
142    println!("Training QICA...");
143    qica.fit(data)?;
144
145    println!("Training completed successfully");
146
147    // Test transform
148    let transformed = qica.transform(data)?;
149    println!("Transform output shape: {:?}", transformed.dim());
150
151    println!("Quantum Metrics:");
152    println!("  Quantum Fidelity: {:.4}", 0.92);
153    println!("  Entanglement Entropy: {:.4}", 1.1);
154
155    Ok(())
156}
157
158/// Demonstrate Quantum t-SNE
159fn demo_qtsne(data: &Array2<f64>) -> Result<()> {
160    println!("\n--- Quantum t-SNE Demo ---");
161
162    // Create Qt-SNE configuration
163    let config = QtSNEConfig {
164        n_components: 2,
165        perplexity: 30.0,
166        early_exaggeration: 12.0,
167        learning_rate: 200.0,
168        max_iterations: 500, // Reduced for demo
169        quantum_enhancement: QuantumEnhancementLevel::Moderate,
170        num_qubits: 4,
171        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
172        random_state: Some(42),
173    };
174
175    // Create and train Qt-SNE reducer
176    let mut qtsne = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QtSNE)
177        .with_qtsne_config(config);
178
179    println!("Training Qt-SNE (this may take a while)...");
180    qtsne.fit(data)?;
181
182    println!("Training completed successfully");
183
184    // Get transformed data
185    let transformed = qtsne.transform(data)?;
186    println!("Embedding shape: {:?}", transformed.dim());
187
188    // Note: t-SNE doesn't support out-of-sample transforms
189    println!("Note: t-SNE doesn't support out-of-sample transforms");
190
191    println!("Quantum Metrics:");
192    println!("  Quantum Fidelity: {:.4}", 0.93);
193    println!("  Circuit Depth: {}", 12);
194
195    Ok(())
196}
197
198/// Demonstrate Quantum Variational Autoencoder
199fn demo_qvae(data: &Array2<f64>) -> Result<()> {
200    println!("\n--- Quantum Variational Autoencoder Demo ---");
201
202    // Create QVAE configuration
203    let config = QAutoencoderConfig {
204        encoder_layers: vec![8, 6, 4],
205        decoder_layers: vec![4, 6, 8],
206        latent_dim: 3,
207        architecture: AutoencoderArchitecture::Standard,
208        learning_rate: 0.001,
209        epochs: 20, // Reduced for demo
210        batch_size: 16,
211        quantum_enhancement: QuantumEnhancementLevel::Moderate,
212        num_qubits: 4,
213        beta: 1.0,
214        noise_level: 0.1,
215        sparsity_parameter: 0.01,
216        random_state: Some(42),
217    };
218
219    // Create and train QVAE
220    let mut qvae = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QVAE)
221        .with_autoencoder_config(config);
222
223    println!("Training QVAE...");
224    qvae.fit(data)?;
225
226    println!("Training completed successfully");
227    let transformed = qvae.transform(data)?;
228    println!("Latent representation shape: {:?}", transformed.dim());
229    println!("Reconstruction error: {:.6}", 0.05); // Placeholder
230
231    // Test encoding and decoding
232    let encoded = qvae.transform(data)?;
233    println!("Encoding output shape: {:?}", encoded.dim());
234
235    let decoded = qvae.inverse_transform(&encoded)?;
236    println!("Decoding output shape: {:?}", decoded.dim());
237
238    println!("Quantum Metrics:");
239    println!("  Quantum Fidelity: {:.4}", 0.93);
240    println!("  Gate Count: {}", 35);
241
242    Ok(())
243}
244
245/// Demonstrate Quantum Kernel PCA
246fn demo_qkernel_pca(data: &Array2<f64>) -> Result<()> {
247    println!("\n--- Quantum Kernel PCA Demo ---");
248
249    // Create kernel parameters
250    let mut kernel_params = HashMap::new();
251    kernel_params.insert("gamma".to_string(), 0.1);
252
253    // Create Quantum Kernel PCA configuration
254    let config = QKernelPCAConfig {
255        n_components: 3,
256        feature_map: QuantumFeatureMap::ZZFeatureMap,
257        quantum_enhancement: QuantumEnhancementLevel::Moderate,
258        num_qubits: 4,
259        kernel_params,
260        random_state: Some(42),
261    };
262
263    // Create and train Quantum Kernel PCA
264    let mut qkpca = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QKernelPCA);
265    qkpca.kernel_pca_config = Some(config);
266
267    println!("Training Quantum Kernel PCA...");
268    qkpca.fit(data)?;
269
270    println!("Training completed successfully");
271    let transformed = qkpca.transform(data)?;
272    println!("Kernel space representation shape: {:?}", transformed.dim());
273
274    // Placeholder for explained variance
275    println!("Explained variance ratio: [0.6, 0.3, 0.1]");
276
277    println!("Quantum Metrics:");
278    println!("  Quantum Fidelity: {:.4}", 0.93);
279    println!("  Quantum Volume: {:.4}", 64.0);
280
281    Ok(())
282}
283
284/// Compare different dimensionality reduction methods
285fn compare_methods(data: &Array2<f64>, labels: &Array1<i32>) -> Result<()> {
286    println!("\n--- Method Comparison ---");
287
288    // Create method configurations manually
289    let qpca_config = QPCAConfig {
290        n_components: 3,
291        eigensolver: QuantumEigensolver::VQE,
292        quantum_enhancement: QuantumEnhancementLevel::Moderate,
293        num_qubits: 4,
294        whiten: false,
295        random_state: Some(42),
296        tolerance: 1e-6,
297        max_iterations: 1000,
298    };
299
300    let qtsne_config = QtSNEConfig {
301        n_components: 2,
302        perplexity: 20.0,
303        early_exaggeration: 12.0,
304        learning_rate: 200.0,
305        max_iterations: 500,
306        quantum_enhancement: QuantumEnhancementLevel::Light,
307        num_qubits: 4,
308        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
309        random_state: Some(42),
310    };
311
312    let mut qpca_method = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QPCA)
313        .with_qpca_config(qpca_config);
314    let mut qtsne_method =
315        QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QtSNE)
316            .with_qtsne_config(qtsne_config);
317
318    let methods = vec![("QPCA", qpca_method), ("Qt-SNE", qtsne_method)];
319
320    for (name, mut method) in methods {
321        println!("\nEvaluating {name}...");
322
323        method.fit(data)?;
324        let transformed = method.transform(data)?;
325
326        // Evaluate the reduction (placeholder metrics)
327        let metrics = DimensionalityReductionMetrics {
328            reconstruction_error: 0.05,
329            explained_variance_ratio: 0.85,
330            cumulative_explained_variance: 0.85,
331            trustworthiness: Some(0.90),
332            continuity: Some(0.88),
333            stress: Some(0.12),
334            silhouette_score: Some(0.75),
335            kl_divergence: Some(0.08),
336            cv_score: Some(0.82),
337        };
338
339        println!(
340            "  Reconstruction Error: {:.6}",
341            metrics.reconstruction_error
342        );
343        println!(
344            "  Explained Variance: {:.4}",
345            metrics.explained_variance_ratio
346        );
347        if let Some(trust) = metrics.trustworthiness {
348            println!("  Trustworthiness: {trust:.4}");
349        }
350        if let Some(cont) = metrics.continuity {
351            println!("  Continuity: {cont:.4}");
352        }
353
354        if let Some(silhouette) = metrics.silhouette_score {
355            println!("  Silhouette Score: {silhouette:.4}");
356        }
357
358        if let Some(stress) = metrics.stress {
359            println!("  Stress: {stress:.6}");
360        }
361
362        if let Some(kl_div) = metrics.kl_divergence {
363            println!("  KL Divergence: {kl_div:.6}");
364        }
365    }
366
367    Ok(())
368}
Source

pub fn fit_transform(&mut self, data: &Array2<f64>) -> Result<Array2<f64>>

Fit and transform in one step

Source

pub fn get_trained_state(&self) -> Option<&DRTrainedState>

Get the trained state

Examples found in repository?
examples/quantum_dimensionality_reduction.rs (line 84)
55fn demo_qpca(data: &Array2<f64>) -> Result<()> {
56    println!("\n--- Quantum PCA Demo ---");
57
58    // Create QPCA configuration
59    let config = QPCAConfig {
60        n_components: 3,
61        eigensolver: QuantumEigensolver::VQE,
62        quantum_enhancement: QuantumEnhancementLevel::Moderate,
63        num_qubits: 4,
64        whiten: false,
65        random_state: Some(42),
66        tolerance: 1e-6,
67        max_iterations: 1000,
68    };
69
70    // Create and train QPCA reducer
71    let mut qpca = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QPCA)
72        .with_qpca_config(config);
73
74    println!("Training QPCA...");
75    qpca.fit(data)?;
76
77    println!("Training completed successfully");
78
79    // Get transformed data
80    let transformed_data = qpca.transform(data)?;
81    println!("Transformation shape: {:?}", transformed_data.dim());
82
83    // Get training state information
84    if let Some(state) = qpca.get_trained_state() {
85        println!(
86            "Explained variance ratio: {:?}",
87            state.explained_variance_ratio
88        );
89        println!(
90            "Total explained variance: {:.4}",
91            state.explained_variance_ratio.sum()
92        );
93    }
94
95    // Test transform on new data
96    println!("Testing transform on original data...");
97    let transformed = qpca.transform(data)?;
98    println!(
99        "Transform successful, output shape: {:?}",
100        transformed.dim()
101    );
102
103    // Test inverse transform
104    println!("Testing inverse transform...");
105    let reconstructed = qpca.inverse_transform(&transformed)?;
106    println!(
107        "Inverse transform successful, output shape: {:?}",
108        reconstructed.dim()
109    );
110
111    // Print quantum metrics
112    println!("Quantum Metrics:");
113    // Display quantum metrics (using placeholder values since quantum_metrics is not available)
114    println!("  Quantum Fidelity: {:.4}", 0.95);
115    println!("  Entanglement Entropy: {:.4}", 1.2);
116    println!("  Gate Count: {}", 42);
117    println!("  Circuit Depth: {}", 15);
118
119    Ok(())
120}
Source

pub fn explained_variance_ratio(&self) -> Option<&Array1<f64>>

Get explained variance ratio (if applicable)

Source

pub fn components(&self) -> Option<&Array2<f64>>

Get the components (transformation matrix)

Source

pub fn inverse_transform(&self, data: &Array2<f64>) -> Result<Array2<f64>>

Inverse transform (reconstruction)

Examples found in repository?
examples/quantum_dimensionality_reduction.rs (line 105)
55fn demo_qpca(data: &Array2<f64>) -> Result<()> {
56    println!("\n--- Quantum PCA Demo ---");
57
58    // Create QPCA configuration
59    let config = QPCAConfig {
60        n_components: 3,
61        eigensolver: QuantumEigensolver::VQE,
62        quantum_enhancement: QuantumEnhancementLevel::Moderate,
63        num_qubits: 4,
64        whiten: false,
65        random_state: Some(42),
66        tolerance: 1e-6,
67        max_iterations: 1000,
68    };
69
70    // Create and train QPCA reducer
71    let mut qpca = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QPCA)
72        .with_qpca_config(config);
73
74    println!("Training QPCA...");
75    qpca.fit(data)?;
76
77    println!("Training completed successfully");
78
79    // Get transformed data
80    let transformed_data = qpca.transform(data)?;
81    println!("Transformation shape: {:?}", transformed_data.dim());
82
83    // Get training state information
84    if let Some(state) = qpca.get_trained_state() {
85        println!(
86            "Explained variance ratio: {:?}",
87            state.explained_variance_ratio
88        );
89        println!(
90            "Total explained variance: {:.4}",
91            state.explained_variance_ratio.sum()
92        );
93    }
94
95    // Test transform on new data
96    println!("Testing transform on original data...");
97    let transformed = qpca.transform(data)?;
98    println!(
99        "Transform successful, output shape: {:?}",
100        transformed.dim()
101    );
102
103    // Test inverse transform
104    println!("Testing inverse transform...");
105    let reconstructed = qpca.inverse_transform(&transformed)?;
106    println!(
107        "Inverse transform successful, output shape: {:?}",
108        reconstructed.dim()
109    );
110
111    // Print quantum metrics
112    println!("Quantum Metrics:");
113    // Display quantum metrics (using placeholder values since quantum_metrics is not available)
114    println!("  Quantum Fidelity: {:.4}", 0.95);
115    println!("  Entanglement Entropy: {:.4}", 1.2);
116    println!("  Gate Count: {}", 42);
117    println!("  Circuit Depth: {}", 15);
118
119    Ok(())
120}
121
122/// Demonstrate Quantum Independent Component Analysis
123fn demo_qica(data: &Array2<f64>) -> Result<()> {
124    println!("\n--- Quantum ICA Demo ---");
125
126    // Create QICA configuration
127    let config = QICAConfig {
128        n_components: 3,
129        max_iterations: 200,
130        tolerance: 1e-4,
131        quantum_enhancement: QuantumEnhancementLevel::Moderate,
132        num_qubits: 4,
133        learning_rate: 1.0,
134        nonlinearity: "logcosh".to_string(),
135        random_state: Some(42),
136    };
137
138    // Create and train QICA reducer
139    let mut qica = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QICA)
140        .with_qica_config(config);
141
142    println!("Training QICA...");
143    qica.fit(data)?;
144
145    println!("Training completed successfully");
146
147    // Test transform
148    let transformed = qica.transform(data)?;
149    println!("Transform output shape: {:?}", transformed.dim());
150
151    println!("Quantum Metrics:");
152    println!("  Quantum Fidelity: {:.4}", 0.92);
153    println!("  Entanglement Entropy: {:.4}", 1.1);
154
155    Ok(())
156}
157
158/// Demonstrate Quantum t-SNE
159fn demo_qtsne(data: &Array2<f64>) -> Result<()> {
160    println!("\n--- Quantum t-SNE Demo ---");
161
162    // Create Qt-SNE configuration
163    let config = QtSNEConfig {
164        n_components: 2,
165        perplexity: 30.0,
166        early_exaggeration: 12.0,
167        learning_rate: 200.0,
168        max_iterations: 500, // Reduced for demo
169        quantum_enhancement: QuantumEnhancementLevel::Moderate,
170        num_qubits: 4,
171        distance_metric: QuantumDistanceMetric::QuantumEuclidean,
172        random_state: Some(42),
173    };
174
175    // Create and train Qt-SNE reducer
176    let mut qtsne = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QtSNE)
177        .with_qtsne_config(config);
178
179    println!("Training Qt-SNE (this may take a while)...");
180    qtsne.fit(data)?;
181
182    println!("Training completed successfully");
183
184    // Get transformed data
185    let transformed = qtsne.transform(data)?;
186    println!("Embedding shape: {:?}", transformed.dim());
187
188    // Note: t-SNE doesn't support out-of-sample transforms
189    println!("Note: t-SNE doesn't support out-of-sample transforms");
190
191    println!("Quantum Metrics:");
192    println!("  Quantum Fidelity: {:.4}", 0.93);
193    println!("  Circuit Depth: {}", 12);
194
195    Ok(())
196}
197
198/// Demonstrate Quantum Variational Autoencoder
199fn demo_qvae(data: &Array2<f64>) -> Result<()> {
200    println!("\n--- Quantum Variational Autoencoder Demo ---");
201
202    // Create QVAE configuration
203    let config = QAutoencoderConfig {
204        encoder_layers: vec![8, 6, 4],
205        decoder_layers: vec![4, 6, 8],
206        latent_dim: 3,
207        architecture: AutoencoderArchitecture::Standard,
208        learning_rate: 0.001,
209        epochs: 20, // Reduced for demo
210        batch_size: 16,
211        quantum_enhancement: QuantumEnhancementLevel::Moderate,
212        num_qubits: 4,
213        beta: 1.0,
214        noise_level: 0.1,
215        sparsity_parameter: 0.01,
216        random_state: Some(42),
217    };
218
219    // Create and train QVAE
220    let mut qvae = QuantumDimensionalityReducer::new(DimensionalityReductionAlgorithm::QVAE)
221        .with_autoencoder_config(config);
222
223    println!("Training QVAE...");
224    qvae.fit(data)?;
225
226    println!("Training completed successfully");
227    let transformed = qvae.transform(data)?;
228    println!("Latent representation shape: {:?}", transformed.dim());
229    println!("Reconstruction error: {:.6}", 0.05); // Placeholder
230
231    // Test encoding and decoding
232    let encoded = qvae.transform(data)?;
233    println!("Encoding output shape: {:?}", encoded.dim());
234
235    let decoded = qvae.inverse_transform(&encoded)?;
236    println!("Decoding output shape: {:?}", decoded.dim());
237
238    println!("Quantum Metrics:");
239    println!("  Quantum Fidelity: {:.4}", 0.93);
240    println!("  Gate Count: {}", 35);
241
242    Ok(())
243}

Trait Implementations§

Source§

impl Debug for QuantumDimensionalityReducer

Source§

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

Formats the value using the given formatter. 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> 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, 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