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

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

Set QPCA configuration

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

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

Set QICA configuration

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

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

Set Qt-SNE configuration

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

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