redstone-ml 0.0.0

High-performance Machine Learning, Auto-Differentiation and Tensor Algebra crate for 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

use crate::{Tensor, TensorDataType};
use std::ops::{Add, Div, Mul, Neg, Sub};

use crate::add_backwards::*;
use crate::div_backwards::*;
use crate::mul_backwards::*;
use crate::neg_backwards::*;
use crate::none_backwards::*;
use crate::sub_backwards::*;
use paste::paste;

impl<T: TensorDataType> Neg for Tensor<'_, T> {
    type Output = Tensor<'static, T>;

    fn neg(self) -> Self::Output { -&self }
}

impl<T: TensorDataType> Neg for &Tensor<'_, T> {
    type Output = Tensor<'static, T>;

    fn neg(self) -> Self::Output {
        let requires_grad = self.requires_grad();
        let grad_fn = if requires_grad { NegBackwards::new(self) } else { NoneBackwards::new() };

        unsafe { Tensor::from_raw_parts(-self.array.as_ref(), requires_grad, grad_fn) }
    }
}

macro_rules! implement_binary_ops {
    ($($trait_: ident, $operator:tt, $method: ident, $backwards:ident, $backwards_scalar:ident;)* ) => { $(
        impl<T: TensorDataType> $trait_<Tensor<'_, T>> for Tensor<'_, T> {
            type Output = Tensor<'static, T>;

            fn $method(self, rhs: Tensor<T>) -> Self::Output { &self $operator &rhs }
        }

        impl<T: TensorDataType> $trait_<&Tensor<'_, T>> for Tensor<'_, T> {
            type Output = Tensor<'static, T>;

            fn $method(self, rhs: &Tensor<T>) -> Self::Output { &self $operator rhs }
        }
        
        impl<T: TensorDataType> $trait_<Tensor<'_, T>> for &Tensor<'_, T> {
            type Output = Tensor<'static, T>;

            fn $method(self, rhs: Tensor<T>) -> Self::Output { self $operator &rhs }
        }

        impl<T: TensorDataType> $trait_<&Tensor<'_, T>> for &Tensor<'_, T> {
            type Output = Tensor<'static, T>;

            fn $method(self, rhs: &Tensor<T>) -> Self::Output {
                let requires_grad = self.requires_grad() || rhs.requires_grad();
                let grad_fn = if requires_grad { $backwards::new(self, rhs) } else { NoneBackwards::new() };

                unsafe { Tensor::from_raw_parts(self.array.as_ref() $operator rhs.array.as_ref(), requires_grad, grad_fn) }
            }
        }
        
        impl<T: TensorDataType> $trait_<T> for Tensor<'_, T> {
            type Output = Tensor<'static, T>;

            fn $method(self, rhs: T) -> Self::Output { paste! { &self $operator rhs } }
        }

        impl<T: TensorDataType> $trait_<T> for &Tensor<'_, T> {
            type Output = Tensor<'static, T>;

            fn $method(self, rhs: T) -> Self::Output {
                let requires_grad = self.requires_grad();
                let grad_fn = if requires_grad { $backwards_scalar::new(self, rhs) } else { NoneBackwards::new() };

                unsafe { Tensor::from_raw_parts(self.array.as_ref() $operator rhs, requires_grad, grad_fn) }
            }
        }
    )*};
}

implement_binary_ops!(
    Add, +, add, AddBackwards, AddScalarBackwards;
    Sub, -, sub, SubBackwards, AddScalarBackwards;
    Mul, *, mul, MulBackwards, MulScalarBackwards;
    Div, /, div, DivBackwards, DivScalarBackwards;
);