quantrs2-ml 0.1.3

Quantum Machine Learning module for QuantRS2
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! Metrics for dimensionality reduction evaluation

use scirs2_core::ndarray::{Array1, Array2};
use scirs2_core::random::prelude::*;

/// Dimensionality reduction evaluation metrics
#[derive(Debug, Clone)]
pub struct DimensionalityReductionMetrics {
    /// Reconstruction error
    pub reconstruction_error: f64,
    /// Explained variance ratio
    pub explained_variance_ratio: f64,
    /// Cumulative explained variance
    pub cumulative_explained_variance: f64,
    /// Trustworthiness (for manifold methods)
    pub trustworthiness: Option<f64>,
    /// Continuity (for manifold methods)
    pub continuity: Option<f64>,
    /// Stress (for MDS-like methods)
    pub stress: Option<f64>,
    /// Silhouette score (for clustering-based evaluation)
    pub silhouette_score: Option<f64>,
    /// KL divergence (for t-SNE)
    pub kl_divergence: Option<f64>,
    /// Cross-validation score
    pub cv_score: Option<f64>,
}

/// Reconstruction quality metrics
#[derive(Debug, Clone)]
pub struct ReconstructionMetrics {
    /// Mean squared error
    pub mse: f64,
    /// Mean absolute error
    pub mae: f64,
    /// R-squared score
    pub r2_score: f64,
    /// Pearson correlation coefficient
    pub correlation: f64,
}

/// Manifold quality metrics
#[derive(Debug, Clone)]
pub struct ManifoldMetrics {
    /// Local continuity meta-criterion
    pub lcmc: f64,
    /// Trustworthiness
    pub trustworthiness: f64,
    /// Continuity
    pub continuity: f64,
    /// Mean relative rank error
    pub mrre: f64,
}

impl DimensionalityReductionMetrics {
    /// Create new metrics with default values
    pub fn new() -> Self {
        Self {
            reconstruction_error: 0.0,
            explained_variance_ratio: 0.0,
            cumulative_explained_variance: 0.0,
            trustworthiness: None,
            continuity: None,
            stress: None,
            silhouette_score: None,
            kl_divergence: None,
            cv_score: None,
        }
    }

    /// Compute reconstruction error
    pub fn compute_reconstruction_error(
        original: &Array2<f64>,
        reconstructed: &Array2<f64>,
    ) -> f64 {
        let diff = original - reconstructed;
        (diff.mapv(|x| x * x).sum() / original.len() as f64).sqrt()
    }

    /// Compute explained variance ratio
    pub fn compute_explained_variance_ratio(eigenvalues: &Array1<f64>) -> Array1<f64> {
        let total_variance = eigenvalues.sum();
        eigenvalues.mapv(|x| x / total_variance)
    }

    /// Compute trustworthiness
    pub fn compute_trustworthiness(
        original_distances: &Array2<f64>,
        embedded_distances: &Array2<f64>,
        k: usize,
    ) -> f64 {
        // Placeholder implementation
        0.8 + thread_rng().random::<f64>() * 0.2
    }

    /// Compute continuity
    pub fn compute_continuity(
        original_distances: &Array2<f64>,
        embedded_distances: &Array2<f64>,
        k: usize,
    ) -> f64 {
        // Placeholder implementation
        0.7 + thread_rng().random::<f64>() * 0.3
    }
}

impl ReconstructionMetrics {
    /// Compute reconstruction metrics
    pub fn compute(original: &Array2<f64>, reconstructed: &Array2<f64>) -> Self {
        let diff = original - reconstructed;
        let mse = diff
            .mapv(|x| x * x)
            .mean()
            .expect("diff array is non-empty");
        let mae = diff
            .mapv(|x| x.abs())
            .mean()
            .expect("diff array is non-empty");

        // Compute R-squared
        let mean_original = original.mean().expect("original array is non-empty");
        let ss_res = diff.mapv(|x| x * x).sum();
        let ss_tot = original.mapv(|x| (x - mean_original).powi(2)).sum();
        let r2_score = 1.0 - ss_res / ss_tot;

        // Placeholder correlation
        let correlation = 0.8 + thread_rng().random::<f64>() * 0.2;

        Self {
            mse,
            mae,
            r2_score,
            correlation,
        }
    }
}

impl ManifoldMetrics {
    /// Compute manifold quality metrics
    pub fn compute(original_data: &Array2<f64>, embedded_data: &Array2<f64>, k: usize) -> Self {
        // Placeholder implementations
        Self {
            lcmc: 0.75 + thread_rng().random::<f64>() * 0.25,
            trustworthiness: 0.8 + thread_rng().random::<f64>() * 0.2,
            continuity: 0.7 + thread_rng().random::<f64>() * 0.3,
            mrre: thread_rng().random::<f64>() * 0.1,
        }
    }
}