deep_core 0.1.1

deep prototype
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

use operations::{Operation, Operand};

use super::{
    graph::{
        Graph, GraphId,
    },
    node::{
        NodeId, Node, Nodes,
    },
    edge::{
        EdgeId, Edge, Edges,
    },
    tensor_descriptor::{
        TensorDescriptor,
    },
};

#[derive(Debug)]
pub struct GraphBuilder {
    nodes: Nodes,
    edges: Edges,
}

impl GraphBuilder {
    pub fn create() -> Self {
        GraphBuilder {
            nodes: Nodes::new(),
            edges: Edges::new(),
        }
    }

    pub fn with_node(mut self, node: Node) -> Self {
        self.nodes.push(node);
        self
    }

    pub fn with_edge(mut self, edge: Edge) -> Self {
        self.edges.push(edge);
        self
    }

    pub fn with_input(self, id: NodeId, tensor_descriptor: TensorDescriptor) -> Self {
        self.with_node(Node::InputNode { id, tensor_descriptor })
    }

    pub fn with_parameter(self, id: NodeId, tensor_descriptor: TensorDescriptor) -> Self {
        self.with_node(Node::ParameterNode { id, tensor_descriptor })
    }

    pub fn with_operation(self, id: NodeId, operation: Operation) -> Self {
        self.with_node(Node::OperationNode { id, operation })
    }

    pub fn with_operand(self, id: EdgeId, from_node: NodeId, to_node: NodeId, operand: Operand) -> Self {
        self.with_edge(Edge::OperandEdge {
            id, 
            connection: (from_node, to_node),
            operand
        })
    }

    pub fn build(self, id: GraphId) -> Graph {
        Graph::new(id, self.nodes, self.edges)
    }
}