tensorrs 0.3.2

Tensors is a lightweight machine learning library in Rust
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

use crate::activation::Function;
use crate::linalg::Matrix;
use crate::Float;

/// Hyperbolic Tangent (Tanh) activation function.
///
/// Maps input values to the range `[-1, 1]`.
///
/// # Mathematical Definition
/// For an input `x`, the Tanh function is defined as:
/// ```math
/// tanh(x) = \frac{e^{2x} - 1}{e^{2x} + 1}
/// ```
///
/// # Examples
/// ```
/// use tensorrs::activation::{Function, Tanh};
/// use tensorrs::linalg::Matrix;
///
/// let tanh = Tanh::new();
/// let input = Matrix::from(vec![vec![0.0], vec![1.0], vec![-1.0]]);
/// let output = tanh.call(input);
/// println!("Tanh output: {}", output);
/// ```
///
/// # See Also
/// - [Wikipedia: Hyperbolic functions](https://en.wikipedia.org/wiki/Hyperbolic_functions)
pub struct Tanh;

impl Tanh {
    /// Creates a new `Tanh` activation function.
    ///
    /// # Returns
    /// A new instance of the `Tanh` activation function.
    pub fn new() -> Self {
        Self
    }

    fn num_fun<T: Float>(&self, num: T) -> T {
        let e_z = num.exp();
        let e_mz = (-num).exp();
        (e_z - e_mz) / (e_z + e_mz)
    }

    fn num_der<T: Float>(&self, num: T) -> T {
        let val = self.num_fun(num);
        T::one() - val * val
    }
}

impl<T: Float> Function<T> for Tanh {
    fn name(&self) -> String {
        "Tanh".to_string()
    }

    fn call(&self, matrix: Matrix<T>) -> Matrix<T> {
        matrix.map(|x| self.num_fun(x))
    }

    fn derivative(&self, matrix: Matrix<T>) -> Matrix<T> {
        matrix.map(|x| self.num_der(x))
    }
}

#[cfg(test)]
mod tests {
    use crate::activation::tanh::Tanh;
    use crate::activation::Function;
    use crate::linalg::Matrix;
    use crate::matrix;

    #[test]
    fn tanh_test() {
        let a = matrix![[1f32, 0f32, 2f32, 3f32]];
        let tanh = Tanh::new();
        println!("{:?} {}", a.shape(), tanh.call(a));
    }

    #[test]
    fn tanh_der() {
        let a = matrix![[1f32, 0f32, 2f32, 3f32]];
        let tanh = Tanh::new();
        println!("{:?} {}", a.shape(), tanh.derivative(a));
    }
}