有趣的TensorSlow(上)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Operation:
    def __init__(self, input_nodes=[]):
        self.input_nodes = input_nodes

        # Initialize list of consumers 
        self.consumers = []

        # Append this operation to the list of consumers of all input nodes
        for input_node in input_nodes:
            input_node.consumers.append(self)

        # Append this operation to the list of operations in the currently active default graph
        _default_graph.operations.append(self)

    def compute(self):
        pass

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Addition Operation节点示例
class add(Operation):
    """Returns x + y element-wise.
    """

    def __init__(self, x, y):
        super().__init__([x, y])

    def compute(self, x_value, y_value):
        self.inputs = [x_value, y_value]
        return x_value + y_value

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Matrix Multiplicaiton Operation节点示例
class matmul(Operation):
    """Multiplies matrix a by matrix b, producing a * b.
    """

    def __init__(self, a, b):
        super().__init__([a, b])

    def compute(self, a_value, b_value):
        self.inputs = [a_value, b_value]
        return a_value.dot(b_value)

1
2
3
4
5
6
7
8

class placeholder:
    """Represents a placeholder node that has to be provided with a value
       when computing the output of a computational graph
    """

    def __init__(self):
        self.consumers = []
        _default_graph.placeholders.append(self)

1
2
3
4
5
6
7
8
9

class Variable:
    """Represents a variable (i.e. an intrinsic, changeable parameter of a computational graph).
    """

    def __init__(self, initial_value=None):
        self.value = initial_value
        self.consumers = []

        _default_graph.variables.append(self)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class Graph:
    def __init__(self):
        """Construct Graph"""
        self.operations = []
        self.placeholders = []
        self.variables = []

    def as_default(self):
        global _default_graph
        _default_graph = self

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Create a new graph
Graph().as_default()

# Create variables
A = Variable([[1, 0], [0, -1]])
b = Variable([1, 1])

# Create placeholder
x = placeholder()

# Create hidden node y
y = matmul(A, x)

# Create output node z
z = add(y, b)

 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

import numpy as np


class Session:
    """Represents a particular execution of a computational graph.
    """

    def run(self, operation, feed_dict={}):
        nodes_postorder = traverse_postorder(operation)
        # Iterate all nodes to determine their value
        for node in nodes_postorder:
            if type(node) == placeholder:
                # Set the node value to the placeholder value from feed_dict
                node.output = feed_dict[node]
            elif type(node) == Variable:
                # Set the node value to the variable's value attribute
                node.output = node.value
            else:  # Operation
                # Get the input values for this operation from node_values
                node.inputs = [input_node.output for input_node in node.input_nodes]
                # Compute the output of this operation
                node.output = node.compute(*node.inputs)

            # Convert lists to numpy arrays
            if type(node.output) == list:
                node.output = np.array(node.output)
        # Return the requested node value
        return operation.output


def traverse_postorder(operation):
    nodes_postorder = []

    def recurse(node):
        if isinstance(node, Operation):
            for input_node in node.input_nodes:
                recurse(input_node)
        nodes_postorder.append(node)

    recurse(operation)
    return nodes_postorder

1
2
3
4
5

session = Session()
output = session.run(z, {
    x: [1, 2]
})
print(output)