dfdx 0.13.0

Ergonomic auto differentiation in Rust, with pytorch like apis.
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

mod cpu_kernel;

#[cfg(feature = "cuda")]
mod cuda_kernel;

use super::ops::{try_unary_op, UnaryKernel};
use crate::{shapes::*, tensor::*};

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct PowiKernelOp(i32);

#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct PowfKernelOp<E>(E);

/// Raises to a float power; `t^i`.
/// ```rust
/// # use dfdx::prelude::*;
/// # let dev: Cpu = Default::default();
/// let t = dev.tensor([-1.0, 0.0, 1.0, 2.0]);
/// let r = t.powf(-3.2);
/// ```
pub fn powf<S: Shape, E: Dtype, D: UnaryKernel<PowfKernelOp<E>, E>, T: Tape<E, D>>(
    t: Tensor<S, E, D, T>,
    exponent: impl Into<f64>,
) -> Tensor<S, E, D, T> {
    t.powf(exponent)
}

impl<S: Shape, E: Dtype, D: UnaryKernel<PowfKernelOp<E>, E>, T: Tape<E, D>> Tensor<S, E, D, T> {
    /// See [powf]
    pub fn powf(self, exponent: impl Into<f64>) -> Self {
        self.try_powf(exponent).unwrap()
    }
    /// See [powf]
    pub fn try_powf(self, exponent: impl Into<f64>) -> Result<Self, D::Err> {
        let exponent = E::from_f64(exponent.into()).unwrap();
        try_unary_op(PowfKernelOp(exponent), self)
    }
}

/// Raises to an integer power; `t^i`.
/// ```rust
/// # use dfdx::prelude::*;
/// # let dev: Cpu = Default::default();
/// let t = dev.tensor([-1.0, 0.0, 1.0, 2.0]);
/// let r = t.powi(3);
/// ```
pub fn powi<S: Shape, E: Dtype, D: UnaryKernel<PowiKernelOp, E>, T: Tape<E, D>>(
    t: Tensor<S, E, D, T>,
    exponent: i32,
) -> Tensor<S, E, D, T> {
    t.powi(exponent)
}

impl<S: Shape, E: Dtype, D: UnaryKernel<PowiKernelOp, E>, T: Tape<E, D>> Tensor<S, E, D, T> {
    /// See [powi]
    pub fn powi(self, exponent: i32) -> Self {
        self.try_powi(exponent).unwrap()
    }
    /// See [powi]
    pub fn try_powi(self, exponent: i32) -> Result<Self, D::Err> {
        try_unary_op(PowiKernelOp(exponent), self)
    }
}

#[cfg(test)]
mod tests {
    use crate::{tensor::*, tensor_ops::*, tests::*};

    #[test]
    fn test_powf_positive() {
        let dev: TestDevice = Default::default();
        let t = dev
            .tensor([-2.0, -1.0, 0.0, 1.0, 2.0])
            .to_dtype::<TestDtype>();
        let r = t.leaky_trace().powf(3.5);
        let r_array = r.array();
        assert!(r_array[0].is_nan());
        assert!(r_array[1].is_nan());
        assert_close!(r_array[2], NumCast::from(0.0).unwrap());
        assert_close!(r_array[3], NumCast::from(1.0).unwrap());
        assert_close!(r_array[4], NumCast::from(11.313708).unwrap());

        let g = r.sum().backward();
        let grad = g.get(&t).array();
        assert!(grad[0].is_nan());
        assert!(grad[1].is_nan());
        assert_close!(grad[2], NumCast::from(0.0).unwrap());
        assert_close!(grad[3], NumCast::from(3.5).unwrap());
        assert_close!(grad[4], NumCast::from(19.79899).unwrap());
    }

    #[test]
    fn test_powf_negative() {
        let dev: TestDevice = Default::default();
        let t = dev
            .tensor([-2.0, -1.0, 0.0, 1.0, 2.0])
            .to_dtype::<TestDtype>();
        let r = t.leaky_trace().powf(-1.2);
        let r_array = r.array();
        assert!(r_array[0].is_nan());
        assert!(r_array[1].is_nan());
        assert_close!(r_array[2], TestDtype::INFINITY);
        assert_close!(r_array[3], NumCast::from(1.0).unwrap());
        assert_close!(r_array[4], NumCast::from(0.43527526).unwrap());

        let g = r.sum().backward();
        let grad = g.get(&t).array();
        assert!(grad[0].is_nan());
        assert!(grad[1].is_nan());
        assert_close!(grad[2], TestDtype::NEG_INFINITY);
        assert_close!(grad[3], NumCast::from(-1.2).unwrap());
        assert_close!(grad[4], NumCast::from(-0.26116517).unwrap());
    }

    #[test]
    fn test_powi_positive() {
        let dev: TestDevice = Default::default();
        let t = dev
            .tensor([-2.0, -1.0, 0.0, 1.0, 2.0])
            .to_dtype::<TestDtype>();
        let r = t.leaky_trace().powi(3);
        assert_close_to_literal!(r, [-8., -1., 0., 1., 8.]);
        let g = r.sum().backward();
        assert_close_to_literal!(g.get(&t), [12., 3., 0., 3., 12.]);
    }

    #[test]
    fn test_powi_negative() {
        let dev: TestDevice = Default::default();
        let t = dev
            .tensor([-2.0, -1.0, 0.0, 1.0, 2.0])
            .to_dtype::<TestDtype>();
        let r = t.leaky_trace().powi(-3);
        assert_close_to_literal!(r, [-0.125, -1.0, f64::INFINITY, 1.0, 0.125]);
        let g = r.sum().backward();
        assert_close_to_literal!(g.get(&t), [-0.1875, -3., f64::NEG_INFINITY, -3., -0.1875]);
    }
}