sklears-manifold 0.1.2

Manifold learning algorithms (t-SNE, Isomap, etc.)
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

//! # VideoManifoldAnalysis - Trait Implementations
//!
//! This module contains trait implementations for `VideoManifoldAnalysis`.
//!
//! ## Implemented Traits
//!
//! - `Fit`
//! - `Transform`
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use scirs2_core::ndarray::{Array2, Array3, Axis};
use scirs2_linalg::compat::ArrayLinalgExt;
use sklears_core::{
    error::{Result as SklResult, SklearsError},
    traits::{Fit, Transform, Untrained},
};

use super::types::{TrainedVideoAnalysis, VideoManifoldAnalysis};

impl Fit<Array3<f64>, ()> for VideoManifoldAnalysis<Untrained> {
    type Fitted = VideoManifoldAnalysis<TrainedVideoAnalysis>;
    fn fit(self, x: &Array3<f64>, _y: &()) -> SklResult<Self::Fitted> {
        let (_n_frames, height, width) = x.dim();
        if height != self.frame_size.0 || width != self.frame_size.1 {
            return Err(SklearsError::InvalidInput(format!(
                "Frame size mismatch: expected {:?}, got ({}, {})",
                self.frame_size, height, width
            )));
        }
        let features = self.extract_temporal_features(x)?;
        let mean_frame = features
            .mean_axis(Axis(0))
            .expect("operation should succeed");
        let centered = &features - &mean_frame.clone().insert_axis(Axis(0));
        let (_, _, vt) = centered
            .svd(false)
            .map_err(|e| SklearsError::NumericalError(format!("SVD failed: {}", e)))?;
        let v: Array2<f64> = vt.t().to_owned();
        let n_comp = self.n_components.min(v.ncols());
        let projection_matrix = v.slice(scirs2_core::ndarray::s![.., ..n_comp]).to_owned();
        let temporal_embedding = centered.dot(&projection_matrix);
        Ok(VideoManifoldAnalysis {
            frame_size: self.frame_size,
            temporal_window: self.temporal_window,
            n_components: self.n_components,
            analysis_method: self.analysis_method.clone(),
            state: TrainedVideoAnalysis {
                frame_size: self.frame_size,
                temporal_window: self.temporal_window,
                n_components: self.n_components,
                analysis_method: self.analysis_method.clone(),
                temporal_embedding,
                projection_matrix,
                mean_frame,
            },
        })
    }
}

impl Transform<Array3<f64>, Array2<f64>> for VideoManifoldAnalysis<TrainedVideoAnalysis> {
    fn transform(&self, x: &Array3<f64>) -> SklResult<Array2<f64>> {
        self.analyze_video(x)
    }
}