lattice-tune 0.2.2

Training infrastructure for Lattice neural 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

//! Model query builder.

use super::registry::ModelRegistry;
use crate::registry::model::{ModelStatus, RegisteredModel};

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

/// Model query builder
#[derive(Debug, Clone, Default)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct ModelQuery {
    name: Option<String>,
    status: Option<ModelStatus>,
    min_accuracy: Option<f32>,
    tags: Vec<String>,
    limit: Option<usize>,
}

impl ModelQuery {
    /// Create a new query
    pub fn new() -> Self {
        Self::default()
    }

    /// Filter by name
    pub fn name(mut self, name: impl Into<String>) -> Self {
        self.name = Some(name.into());
        self
    }

    /// Filter by status
    pub fn status(mut self, status: ModelStatus) -> Self {
        self.status = Some(status);
        self
    }

    /// Filter by minimum accuracy
    pub fn min_accuracy(mut self, accuracy: f32) -> Self {
        self.min_accuracy = Some(accuracy);
        self
    }

    /// Filter by tag
    pub fn tag(mut self, tag: impl Into<String>) -> Self {
        self.tags.push(tag.into());
        self
    }

    /// Limit results
    pub fn limit(mut self, limit: usize) -> Self {
        self.limit = Some(limit);
        self
    }

    /// Execute query against registry
    ///
    /// Returns owned `RegisteredModel` values (cloned from the registry snapshot).
    pub fn execute(&self, registry: &ModelRegistry) -> Vec<RegisteredModel> {
        let mut results: Vec<RegisteredModel> = registry
            .list_all()
            .into_iter()
            .filter(|m| {
                // Name filter
                if let Some(ref name) = self.name {
                    if &m.name != name {
                        return false;
                    }
                }

                // Status filter
                if let Some(ref status) = self.status {
                    if &m.status != status {
                        return false;
                    }
                }

                // Accuracy filter
                if let Some(min_acc) = self.min_accuracy {
                    if let Some(acc) = m.metadata.validation_accuracy {
                        if acc < min_acc {
                            return false;
                        }
                    } else {
                        return false;
                    }
                }

                // Tag filter
                for tag in &self.tags {
                    if !m.metadata.tags.contains(tag) {
                        return false;
                    }
                }

                true
            })
            .collect();

        // Apply limit
        if let Some(limit) = self.limit {
            results.truncate(limit);
        }

        results
    }
}