rotta_rs 0.0.6

a Deep Learning library with rust language
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
142
143

use std::{ fmt::Display, ops::Range, sync::{ Arc, Mutex } };

use rand::random;

use crate::{
    rotta_rs_module::{ arrayy::{ Arrayy, RecFlatten }, BackwardLabel, Node, NodeType },
    TensorRange,
};

#[derive(Debug, Clone)]
pub struct Tensor {
    pub node: NodeType,
}

impl Tensor {
    // initialization
    pub fn new<T: RecFlatten>(arr: T) -> Tensor {
        let (shape, vector) = arr.rec_flatten();
        let arr = Arrayy::from_vector(shape, vector);
        let node = Arc::new(Mutex::new(Node::new(arr)));

        Tensor {
            node,
        }
    }

    pub fn from_arrayy(array: Arrayy) -> Tensor {
        let node = Node::new(array);
        let node = Arc::new(Mutex::new(node));

        let tensor = Tensor {
            node,
        };

        tensor
    }

    pub fn from_vector(shape: Vec<usize>, vector: Vec<f64>) -> Tensor {
        let array = Arrayy::from_vector(shape, vector);

        let node = Node::new(array);
        let node = Arc::new(Mutex::new(node));

        let tensor = Tensor {
            node,
        };

        tensor
    }

    pub fn from_element(shape: Vec<usize>, element: f64) -> Tensor {
        let array = Arrayy::arrayy_from_element(shape, element);

        let node = Node::new(array);
        let node = Arc::new(Mutex::new(node));

        let tensor = Tensor {
            node,
        };

        tensor
    }

    pub fn from_shape_fn<T: FnMut() -> f64>(shape: Vec<usize>, f: T) -> Tensor {
        let array = Arrayy::arrayy_from_shape_fn(shape, f);

        let node = Node::new(array);
        let node = Arc::new(Mutex::new(node));

        let tensor = Tensor {
            node,
        };

        tensor
    }

    pub fn rand(shape: Vec<usize>) -> Tensor {
        Tensor::from_arrayy(Arrayy::arrayy_from_shape_fn(shape, || random::<f64>()))
    }

    pub fn arange(range: Range<usize>) -> TensorRange {
        TensorRange::init(range)
    }

    pub fn zeros(shape: Vec<usize>) -> Tensor {
        Tensor::from_arrayy(Arrayy::zeros(shape))
    }

    // get
    // value
    pub fn value(&self) -> Arrayy {
        self.node.lock().unwrap().value.clone()
    }

    // requires gradient
    pub fn requires_grad(&self) -> bool {
        self.node.lock().unwrap().requires_grad
    }

    // grad
    pub fn grad(&self) -> Arrayy {
        self.node.lock().unwrap().grad.clone()
    }

    // shape
    pub fn shape(&self) -> Vec<usize> {
        self.node.lock().unwrap().value.shape.clone()
    }

    // update
    // parent
    pub fn update_parent(&self, parent: Vec<NodeType>) {
        self.node.lock().as_mut().unwrap().parent = parent;
    }

    // label
    pub fn update_label(&self, label: Option<BackwardLabel>) {
        self.node.lock().as_mut().unwrap().label = label;
    }

    pub fn update_parent_label(&self, parent: Vec<NodeType>, label: Option<BackwardLabel>) {
        let mut node = self.node.lock().unwrap();
        node.parent = parent;
        node.label = label;
    }

    // requires grad
    pub fn set_requires_grad(&self, stat: bool) {
        self.node.lock().unwrap().requires_grad = stat;
    }

    // auto zero grad
    pub fn set_auto_zero_grad(&self, stat: bool) {
        self.node.lock().unwrap().auto_zero_grad = stat;
    }
}

impl Display for Tensor {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let string = format!("{}", self.node.lock().unwrap().value);
        f.write_str(&string)
    }
}