entrenar 0.7.8

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
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

//! WASM deployment budget constraints and violations.

use serde::{Deserialize, Serialize};

/// Maximum startup latency for mobile web targets (milliseconds)
const MOBILE_MAX_STARTUP_MS: u64 = 200;
/// Default maximum startup latency for WASM deployment (milliseconds)
const DEFAULT_MAX_STARTUP_MS: u64 = 500;

/// WASM deployment budget constraints
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WasmBudget {
    /// Maximum binary size in bytes (default: 5 MB)
    pub max_binary_size: u64,
    /// Maximum startup latency in milliseconds (default: 500 ms)
    pub max_startup_ms: u64,
    /// Maximum memory usage in bytes (default: 256 MB)
    pub max_memory_bytes: u64,
}

impl WasmBudget {
    /// Create new WASM budget
    pub fn new(max_binary_size: u64, max_startup_ms: u64, max_memory_bytes: u64) -> Self {
        Self { max_binary_size, max_startup_ms, max_memory_bytes }
    }

    /// Create a strict budget for mobile web
    pub fn mobile() -> Self {
        Self {
            max_binary_size: 2 * 1024 * 1024, // 2 MB
            max_startup_ms: MOBILE_MAX_STARTUP_MS,
            max_memory_bytes: 128 * 1024 * 1024, // 128 MB
        }
    }

    /// Create a standard budget for desktop web
    pub fn desktop() -> Self {
        Self {
            max_binary_size: 10 * 1024 * 1024,   // 10 MB
            max_startup_ms: 1000,                // 1 second
            max_memory_bytes: 512 * 1024 * 1024, // 512 MB
        }
    }

    /// Create a relaxed budget for embedded/IoT
    pub fn embedded() -> Self {
        Self {
            max_binary_size: 1024 * 1024,       // 1 MB
            max_startup_ms: 100,                // 100 ms
            max_memory_bytes: 64 * 1024 * 1024, // 64 MB
        }
    }

    /// Get budget sizes in MB
    pub fn sizes_mb(&self) -> (f64, f64) {
        (
            self.max_binary_size as f64 / (1024.0 * 1024.0),
            self.max_memory_bytes as f64 / (1024.0 * 1024.0),
        )
    }
}

impl Default for WasmBudget {
    fn default() -> Self {
        Self {
            max_binary_size: 5 * 1024 * 1024, // 5 MB
            max_startup_ms: DEFAULT_MAX_STARTUP_MS,
            max_memory_bytes: 256 * 1024 * 1024, // 256 MB
        }
    }
}

/// Budget violation details
#[derive(Debug, Clone, PartialEq)]
pub enum BudgetViolation {
    /// Binary size exceeds limit
    BinarySize { actual: u64, limit: u64 },
    /// Startup latency exceeds limit
    StartupLatency { actual: u64, limit: u64 },
    /// Memory footprint exceeds limit
    MemoryFootprint { actual: u64, limit: u64 },
}

impl std::fmt::Display for BudgetViolation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::BinarySize { actual, limit } => {
                write!(
                    f,
                    "Binary size {} MB exceeds {} MB limit",
                    *actual as f64 / (1024.0 * 1024.0),
                    *limit as f64 / (1024.0 * 1024.0)
                )
            }
            Self::StartupLatency { actual, limit } => {
                write!(f, "Startup latency {actual} ms exceeds {limit} ms limit")
            }
            Self::MemoryFootprint { actual, limit } => {
                write!(
                    f,
                    "Memory footprint {} MB exceeds {} MB limit",
                    *actual as f64 / (1024.0 * 1024.0),
                    *limit as f64 / (1024.0 * 1024.0)
                )
            }
        }
    }
}