gtensor 1.0.0

Reverse-mode autodifferentiation of computational graphs with tensors and more for machine learning.
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


use std::sync::Arc;
use std::sync::RwLock;

use serde::{Serialize, Deserialize};

use super::arena::ArenaIndex;
use super::arena::Arena;
use super::node::Node;
use crate::tensor::shape::Shape;
use crate::operators::Operator;

// Arena Serialization / Deserialization

#[derive(Serialize, Deserialize)]
pub struct ArenaSerde {
    outputs: Vec<usize>,
    gradients: Vec<usize>,
    parameters: Vec<Vec<f32>>,
}

impl ArenaSerde {
    pub fn from_arena(arena: &Arena) -> Self {
        Self {
            outputs: arena.outputs.iter().map(|data| data.read().unwrap().len()).collect(),
            gradients: arena.gradients.iter().map(|data| data.read().unwrap().len()).collect(),
            parameters: arena.parameters.iter().map(|data| data.read().unwrap().clone()).collect(),
        }
    }

    pub fn to_arena(&self) -> Arena {
        Arena {
            outputs: self.outputs.iter().map(|len| Arc::new(RwLock::new(vec![0.0; *len]))).collect(),
            gradients: self.gradients.iter().map(|len| Arc::new(RwLock::new(vec![0.0; *len]))).collect(),
            parameters: self.parameters.iter().map(|data| Arc::new(RwLock::new(data.clone()))).collect(),
        }
    }
}

// Node Serialization / Deserialization 

#[derive(Serialize, Deserialize)]
pub struct NodeSerde {
    y: GTensorSerde,
    gy: GTensorSerde,
    x: Vec<GTensorSerde>,
    gx: Vec<GTensorSerde>,
    is_batched: bool,
}

impl NodeSerde {
    pub fn from_node(node: &Node) -> Self {
        Self{
            y: GTensorSerde {
                index: node.y.index,
                shape: node.y.shape,
                is_batched: node.is_batched,
            },
            gy: GTensorSerde {
                index: node.gy.index,
                shape: node.gy.shape,
                is_batched: node.is_batched,
            },
            x: node.x.iter().map(|gt| GTensorSerde {
                index: gt.index,
                shape: gt.shape,
                is_batched: gt.is_batched,
            }).collect(),
            gx: node.gx.iter().map(|gt| GTensorSerde {
                index: gt.index,
                shape: gt.shape,
                is_batched: gt.is_batched,
            }).collect(),
            is_batched: node.is_batched,
        }
    }

    pub fn to_node(&self, arena: &Arena) -> Node {
        Node {
            y: arena.load(self.y),
            gy: arena.load(self.gy),
            x: self.x.iter().map(|gt| arena.load(*gt)).collect(),
            gx: self.gx.iter().map(|gt| arena.load(*gt)).collect(),
            is_batched: self.is_batched,
        }
    }
}

// GTensor Serialization / Deserialization

#[derive(Copy, Clone, Serialize, Deserialize)]
pub struct GTensorSerde {
    pub index: ArenaIndex,
    pub shape: Shape,
    pub is_batched: bool,
}

// Operator Serialization / Deserialization

#[derive(Serialize, Deserialize)]
pub struct OperatorSerde {
    #[serde(with = "serde_traitobject")]
    op: Box<dyn Operator>,
}

impl OperatorSerde {
    pub fn to_op(self) -> Box<dyn Operator> {
        self.op
    }

    pub fn from_op(op: &Box<dyn Operator>) -> Self {
        Self { op: dyn_clone::clone_box(op.as_ref()) }
    }
}