entrenar 0.7.10

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

//! Property-based tests for gradual pruning schedule.

use crate::prune::schedule::PruningSchedule;
use proptest::prelude::*;

proptest! {
    /// Gradual sparsity is always monotonically increasing
    #[test]
    fn gradual_monotonic(
        start in 0usize..1000,
        duration in 1usize..1000,
        initial in 0.0f32..0.5,
        final_val in 0.5f32..1.0,
    ) {
        let schedule = PruningSchedule::Gradual {
            start_step: start,
            end_step: start + duration,
            initial_sparsity: initial,
            final_sparsity: final_val,
            frequency: 1,
        };

        let mut prev = initial;
        for step in start..=(start + duration) {
            let sparsity = schedule.sparsity_at_step(step);
            prop_assert!(sparsity >= prev - 1e-5);
            prev = sparsity;
        }
    }

    /// Sparsity is always bounded by initial and final
    #[test]
    fn sparsity_bounded(
        start in 0usize..100,
        duration in 1usize..100,
        initial in 0.0f32..0.5,
        final_val in 0.5f32..1.0,
        test_step in 0usize..500,
    ) {
        let schedule = PruningSchedule::Gradual {
            start_step: start,
            end_step: start + duration,
            initial_sparsity: initial,
            final_sparsity: final_val,
            frequency: 1,
        };

        let sparsity = schedule.sparsity_at_step(test_step);
        prop_assert!(sparsity >= initial - 1e-6);
        prop_assert!(sparsity <= final_val + 1e-6);
    }

    /// Serialize/deserialize roundtrip
    #[test]
    fn serde_roundtrip(
        start in 0usize..1000,
        duration in 1usize..1000,
        initial in 0.0f32..0.5,
        final_val in 0.5f32..1.0,
    ) {
        let schedule = PruningSchedule::Gradual {
            start_step: start,
            end_step: start + duration,
            initial_sparsity: initial,
            final_sparsity: final_val,
            frequency: 10,
        };

        let json = serde_json::to_string(&schedule);
        prop_assert!(json.is_ok(), "serialize failed: {:?}", json.err());
        let json = json.expect("operation should succeed");
        let deserialized: Result<PruningSchedule, _> = serde_json::from_str(&json);
        prop_assert!(deserialized.is_ok(), "deserialize failed: {:?}", deserialized.err());
        prop_assert_eq!(schedule, deserialized.expect("deserialization should succeed"));
    }
}