latent-inspector 0.1.0

Fast CLI for inspecting and comparing learned representations across self-supervised vision models
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

use crate::analysis::{ComparisonMetrics, ModelMetrics};
use crate::errors::VizError;
use crate::models::{ModelCatalogReport, ModelDownloadReport};
use crate::validation::report::ModelValidationSummary;
use crate::viz::report::{
    CompareReport, DriftReport, InspectReport, NeighborsReport, ProfileReport, SimilarityReport,
};
use serde::Serialize;
use std::path::Path;

/// Render model metrics as pretty-printed JSON to stdout.
pub fn print_metrics(metrics: &[ModelMetrics]) -> Result<(), VizError> {
    print_value(metrics)
}

/// Render comparison metrics as pretty-printed JSON to stdout.
pub fn print_comparison(comparisons: &[ComparisonMetrics]) -> Result<(), VizError> {
    print_value(comparisons)
}

pub fn print_validation_summaries(summaries: &[ModelValidationSummary]) -> Result<(), VizError> {
    print_value(summaries)
}

pub fn print_compare_report(report: &CompareReport) -> Result<(), VizError> {
    print_value(report)
}

pub fn write_compare_report(report: &CompareReport, path: &Path) -> Result<(), VizError> {
    write_value(report, path)
}

pub fn print_inspect_report(report: &InspectReport) -> Result<(), VizError> {
    print_value(report)
}

pub fn write_inspect_report(report: &InspectReport, path: &Path) -> Result<(), VizError> {
    write_value(report, path)
}

pub fn write_validation_report(
    summaries: &[ModelValidationSummary],
    path: &Path,
) -> Result<(), VizError> {
    write_value(summaries, path)
}

pub fn print_neighbors_report(report: &NeighborsReport) -> Result<(), VizError> {
    print_value(report)
}

pub fn write_neighbors_report(report: &NeighborsReport, path: &Path) -> Result<(), VizError> {
    write_value(report, path)
}

pub fn print_similarity_report(report: &SimilarityReport) -> Result<(), VizError> {
    print_value(report)
}

pub fn write_similarity_report(report: &SimilarityReport, path: &Path) -> Result<(), VizError> {
    write_value(report, path)
}

pub fn print_drift_report(report: &DriftReport) -> Result<(), VizError> {
    print_value(report)
}

pub fn write_drift_report(report: &DriftReport, path: &Path) -> Result<(), VizError> {
    write_value(report, path)
}

pub fn print_model_catalog(report: &ModelCatalogReport) -> Result<(), VizError> {
    print_value(report)
}

pub fn write_model_catalog(report: &ModelCatalogReport, path: &Path) -> Result<(), VizError> {
    write_value(report, path)
}

pub fn print_model_download_report(report: &ModelDownloadReport) -> Result<(), VizError> {
    print_value(report)
}

pub fn write_model_download_report(
    report: &ModelDownloadReport,
    path: &Path,
) -> Result<(), VizError> {
    write_value(report, path)
}

pub fn print_profile_report(report: &ProfileReport) -> Result<(), VizError> {
    print_value(report)
}

pub fn write_profile_report(report: &ProfileReport, path: &Path) -> Result<(), VizError> {
    write_value(report, path)
}

fn print_value<T: Serialize + ?Sized>(value: &T) -> Result<(), VizError> {
    let json = serialize_pretty(value)?;
    println!("{json}");
    Ok(())
}

fn write_value<T: Serialize + ?Sized>(value: &T, path: &Path) -> Result<(), VizError> {
    let json = serialize_pretty(value)?;
    std::fs::write(path, json)
        .map_err(|e| VizError::Json(format!("Failed to write {}: {e}", path.display())))?;
    Ok(())
}

fn serialize_pretty<T: Serialize + ?Sized>(value: &T) -> Result<String, VizError> {
    serde_json::to_string_pretty(value)
        .map_err(|e| VizError::Json(format!("JSON serialization failed: {e}")))
}

#[cfg(test)]
mod tests {
    use super::*;

    fn dummy_metrics() -> ModelMetrics {
        ModelMetrics {
            model_name: "test".into(),
            n_patches: 256,
            embed_dim: 1024,
            effective_rank: 128,
            dead_dimensions: 0,
            patch_entropy: 2.5,
            attention_gini: Some(0.42),
            cls_l2_norm: Some(18.4),
            patch_norm_mean: 12.0,
            patch_norm_std: 2.0,
            top10_variance_pct: 45.0,
            components_90pct: 32,
            patch_isotropy: 0.65,
            patch_uniformity: -2.1,
        }
    }

    #[test]
    fn test_serialization_roundtrip() {
        let m = dummy_metrics();
        let json = serde_json::to_string_pretty(&m).unwrap();
        let parsed: ModelMetrics = serde_json::from_str(&json).unwrap();
        assert_eq!(parsed.model_name, "test");
        assert_eq!(parsed.effective_rank, 128);
    }
}