fast_aug 0.1.0

Fast data augmentation for text
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

use crate::base::BaseAugmenter;
use std::sync::Arc;

pub struct SequentialAugmenter<T, K> {
    /// The augmenters to apply in sequence
    /// Added Send + Sync for multi-threading safety
    augmenters: Vec<Arc<dyn BaseAugmenter<T, K> + Send + Sync>>,
}

impl<T, K> SequentialAugmenter<T, K> {
    pub fn new(augmenters: Vec<Arc<dyn BaseAugmenter<T, K> + Send + Sync>>) -> Self {
        if augmenters.is_empty() {
            panic!("SequentialAugmenter must have at least one augmenter");
        }
        SequentialAugmenter { augmenters }
    }
}

impl<T, K> BaseAugmenter<T, K> for SequentialAugmenter<T, K> {
    fn augment_inner(&self, input: K, rng: &mut dyn rand::RngCore) -> K {
        self.augmenters
            .iter()
            .fold(input, |acc, augmenter| augmenter.augment_inner(acc, rng))
    }

    fn convert_to_inner(&self, input: T) -> K {
        self.augmenters[0].convert_to_inner(input)
    }

    fn convert_to_outer(&self, input: K) -> T {
        self.augmenters[0].convert_to_outer(input)
    }
}

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

    struct DummyMultiplyAugmenter;

    impl BaseAugmenter<i32, i32> for DummyMultiplyAugmenter {
        fn augment_inner(&self, input: i32, _rng: &mut dyn rand::RngCore) -> i32 {
            input * 2
        }
        fn convert_to_inner(&self, input: i32) -> i32 {
            input
        }
        fn convert_to_outer(&self, input: i32) -> i32 {
            input
        }
    }

    struct DummyAddAugmenter;

    impl BaseAugmenter<i32, i32> for DummyAddAugmenter {
        fn augment_inner(&self, input: i32, _rng: &mut dyn rand::RngCore) -> i32 {
            input + 1
        }
        fn convert_to_inner(&self, input: i32) -> i32 {
            input
        }
        fn convert_to_outer(&self, input: i32) -> i32 {
            input
        }
    }

    #[test]
    fn test_sequential_augmenter_works() {
        let augmenter1 = Arc::new(DummyMultiplyAugmenter);
        let augmenter2 = Arc::new(DummyAddAugmenter);
        let sequential_augmenter = SequentialAugmenter::new(vec![augmenter1, augmenter2]);

        let output = sequential_augmenter.augment(1, &mut rand::thread_rng());

        assert_eq!(output, 3);
    }

    #[test]
    fn test_sequential_augmenter_works_with_multiple_augmenters() {
        let augmenter1 = Arc::new(DummyMultiplyAugmenter);
        let augmenter2 = Arc::new(DummyAddAugmenter);
        let augmenter3 = Arc::new(DummyMultiplyAugmenter);
        let sequential_augmenter = SequentialAugmenter::new(vec![augmenter1, augmenter2, augmenter3]);

        let output = sequential_augmenter.augment(1, &mut rand::thread_rng());

        assert_eq!(output, 6);
    }
}