encoderfile 0.6.2

Distribute and run transformer encoders with a single file.
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

use super::Tensor;
use mlua::prelude::*;
use ndarray::Axis;

impl Tensor {
    #[tracing::instrument(skip_all)]
    pub fn truncate_axis(&self, axis: isize, len: usize) -> Result<Self, LuaError> {
        let axis = self.axis1(axis)?;

        let actual_len = self.0.len_of(axis).min(len);

        let mut slice_spec = Vec::with_capacity(self.0.ndim());

        for i in 0..self.0.ndim() {
            if Axis(i) == axis {
                slice_spec.push(ndarray::SliceInfoElem::Slice {
                    start: 0,
                    end: Some(actual_len as isize),
                    step: 1,
                });
            } else {
                slice_spec.push(ndarray::SliceInfoElem::Slice {
                    start: 0,
                    end: None,
                    step: 1,
                });
            }
        }

        Ok(Tensor(self.0.slice(&slice_spec[..]).to_owned()))
    }
}

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

    #[test]
    fn test_truncate_axis_correctness() {
        use ndarray::Array3;
        let tensor = Tensor(Array3::from_elem([3, 3, 3], 1.0).into_dyn());

        // truncate along 2rd axis (3rd in lua land) to 2
        let result = tensor
            .truncate_axis(3, 2)
            .expect("Failed to truncate tensor");
        let expected = Tensor(Array3::from_elem([3, 3, 2], 1.0).into_dyn());

        assert_eq!(result, expected);
    }

    #[test]
    fn test_truncate_axis_out_of_bounds() {
        use ndarray::Array3;
        let tensor = Tensor(Array3::from_elem([3, 3, 3], 1.0).into_dyn());

        // should return the same thing
        let result = tensor
            .truncate_axis(3, 500)
            .expect("Failed to truncate tensor");
        let expected = Tensor(Array3::from_elem([3, 3, 3], 1.0).into_dyn());

        assert_eq!(result, expected);
    }
}