entrenar 0.7.13

Training & Optimization library with autograd, LoRA, quantization, and model merging
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

//! Distribution tier levels

use serde::{Deserialize, Serialize};

/// Distribution tier levels
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
pub enum DistributionTier {
    /// ~50MB: entrenar-core, trueno, aprender
    #[default]
    Core,
    /// ~200MB: + renacer, trueno-db, ruchy
    Standard,
    /// ~500MB: + GPU support, all tooling
    Full,
}

impl DistributionTier {
    /// Get the approximate size in megabytes
    pub fn approximate_size_mb(&self) -> u64 {
        match self {
            Self::Core => 50,
            Self::Standard => 200,
            Self::Full => 500,
        }
    }

    /// Get the core component names for this tier
    pub fn component_names(&self) -> Vec<&'static str> {
        match self {
            Self::Core => vec!["entrenar-core", "trueno", "aprender"],
            Self::Standard => {
                vec!["entrenar-core", "trueno", "aprender", "renacer", "trueno-db", "ruchy"]
            }
            Self::Full => vec![
                "entrenar-core",
                "trueno",
                "aprender",
                "renacer",
                "trueno-db",
                "ruchy",
                "entrenar-gpu",
                "entrenar-bench",
                "entrenar-inspect",
                "entrenar-lora",
                "entrenar-shell",
            ],
        }
    }

    /// Check if this tier includes a specific component
    pub fn includes(&self, component: &str) -> bool {
        self.component_names().contains(&component)
    }
}

impl std::fmt::Display for DistributionTier {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Core => write!(f, "core"),
            Self::Standard => write!(f, "standard"),
            Self::Full => write!(f, "full"),
        }
    }
}