def architecture_children(self): children = self.raw_children() gate = children["gate"] transform = children["transform"] # prepare gates transform_gate = tn.SequentialNode( self.name + "_transformgate", [ gate, # add initial value as bias instead # TODO parameterize tn.AddConstantNode(self.name + "_biastranslation", value=-4), tn.SigmoidNode(self.name + "_transformgatesigmoid") ]) # carry gate = 1 - transform gate carry_gate = tn.SequentialNode(self.name + "_carrygate", [ tn.ReferenceNode(self.name + "_transformgateref", reference=transform_gate.name), tn.MultiplyConstantNode(self.name + "_invert", value=-1), tn.AddConstantNode(self.name + "_add", value=1) ]) # combine with gates gated_transform = tn.ElementwiseProductNode( self.name + "_gatedtransform", [transform_gate, transform]) gated_carry = tn.ElementwiseProductNode( self.name + "_gatedcarry", [carry_gate, tn.IdentityNode(self.name + "_carry")]) res = tn.ElementwiseSumNode(self.name + "_res", [gated_carry, gated_transform]) return [res]
def GeometricMeanOutNode(name, epsilon=1e-8, **kwargs): return tn.SequentialNode(name, [ tn.ReLUNode(name + "_relu"), tn.AddConstantNode(name + "_add", value=epsilon), TimesoutNode(name + "_to", **kwargs), tn.SqrtNode(name + "_sqrt"), tn.AddConstantNode(name + "_sub", value=-(epsilon**2)) ])
def test_remove_parents(): network1 = tn.SequentialNode("seq", [ tn.InputNode("i", shape=()), tn.HyperparameterNode("hp1", tn.HyperparameterNode( "hp2", tn.AddConstantNode("ac"), value=1), value=2) ]).network() network2 = canopy.transforms.remove_parents(network1, "ac") nt.assert_equal(tn.AddConstantNode("ac"), network2.root_node)
def architecture_children(self): gate_node = tn.SequentialNode( self.name + "_gate_seq", [ batch_fold.AddAxisNode(self.name + "_add_axis", axis=2), batch_fold.FoldUnfoldAxisIntoBatchNode( self.name + "_batch_fold", # NOTE: using dnn conv, since pooling is normally strided # and the normal conv is slow with strides tn.DnnConv2DWithBiasNode(self.name + "_conv", num_filters=1), axis=1), batch_fold.RemoveAxisNode(self.name + "_remove_axis", axis=2), tn.SigmoidNode(self.name + "_gate_sigmoid") ]) inverse_gate_node = tn.SequentialNode(self.name + "_max_gate", [ tn.ReferenceNode(self.name + "_gate_ref", reference=gate_node.name), tn.MultiplyConstantNode(self.name + "_", value=-1), tn.AddConstantNode(self.name + "_add1", value=1) ]) mean_node = tn.ElementwiseProductNode( self.name + "_mean_product", [tn.MeanPool2DNode(self.name + "_mean_pool"), gate_node]) max_node = tn.ElementwiseProductNode( self.name + "_max_product", [tn.MaxPool2DNode(self.name + "_max_pool"), inverse_gate_node]) return [ tn.ElementwiseSumNode(self.name + "_sum", [mean_node, max_node]) ]
def test_auxiliary_cost_node(): network = tn.HyperparameterNode( "hp", tn.SequentialNode("seq", [ tn.InputNode("x", shape=(3, 4, 5)), tn.AuxiliaryCostNode( "cost1", {"target": tn.InputNode("y1", shape=(3, 4, 5))}), tn.AddConstantNode("a1", value=2), tn.AuxiliaryCostNode( "cost2", {"target": tn.InputNode("y2", shape=(3, 4, 5))}), tn.MultiplyConstantNode("m1", value=2), tn.AuxiliaryCostNode( "cost3", {"target": tn.InputNode("y3", shape=(3, 4, 5))}), tn.ConstantNode("const", value=0), tn.InputElementwiseSumNode("cost") ]), cost_reference="cost", cost_function=treeano.utils.squared_error, ).network() fn = network.function(["x", "y1", "y2", "y3"], ["cost"]) x = np.random.rand(3, 4, 5).astype(fX) ys = [np.random.rand(3, 4, 5).astype(fX) for _ in range(3)] def mse(x, y): return ((x - y)**2).mean() expected_output = (mse(x, ys[0]) + mse(x + 2, ys[1]) + mse(2 * (x + 2), ys[2])) np.testing.assert_allclose(fn(x, *ys)[0], expected_output, rtol=1e-5)
def test_with_hyperparameters(): network = tn.SequentialNode( "seq", [tn.InputNode("i", shape=()), tn.AddConstantNode("ac")]).network() fn = canopy.handlers.handled_fn( network, [canopy.handlers.with_hyperparameters("hp", value=3)], {"x": "i"}, {"out": "ac"}) nt.assert_equal(3, fn({"x": 0})["out"])
def test_override_hyperparameters1(): network = tn.SequentialNode( "seq", [tn.InputNode("i", shape=()), tn.AddConstantNode("ac", value=1)]).network() fn = canopy.handlers.handled_fn( network, [canopy.handlers.override_hyperparameters(value=2)], {"x": "i"}, {"out": "ac"}) nt.assert_equal(2, fn({"x": 0})["out"])
def test_dict_children_container_schema_optional_children(): dccs = core.DictChildrenContainerSchema( foo=core.ListChildrenContainer, bar=core.ChildContainer, ) node = tn.AddConstantNode("hello") in_map = {"foo": [node, node]} cc = dccs(in_map) # test that .children returns the same as the input nt.assert_equal(cc.children, in_map)
def test_graph_node_no_input(): network = tn.GraphNode( "g", [(tn.InputNode("i", shape=()), tn.MultiplyConstantNode("m1", value=2), tn.AddConstantNode("a1", value=2)), [{"from": "i", "to": "a1"}, {"from": "a1", "to": "m1"}, {"from": "m1"}]] ).network() fn = network.function(["i"], ["g"]) nt.assert_equal([10], fn(3))
def test_graph_node_no_output_key(): network = tn.SequentialNode( "s", [tn.InputNode("i", shape=()), tn.GraphNode("g", [(tn.MultiplyConstantNode("m1", value=2), tn.AddConstantNode("a1", value=2)), [{"to": "a1"}, {"from": "a1", "to": "m1"}, {"from": "m1", "to_key": "foo"}]])] ).network() fn = network.function(["i"], ["s"]) nt.assert_equal([3], fn(3))
def test_dict_children_container_schema_serialization(): dccs = core.DictChildrenContainerSchema( foo=core.ListChildrenContainer, bar=core.ChildContainer, ) node = tn.AddConstantNode("hello") in_map = {"foo": [node, node], "bar": node} cc1 = dccs(in_map) cc2 = core.children_container_from_data( core.children_container_to_data(cc1)) nt.assert_equal(cc1.__class__, cc2.__class__) nt.assert_equal(cc1.__dict__, cc2.__dict__)
def test_add_hyperparameters(): network1 = treeano.Network(tn.SequentialNode( "seq", [tn.InputNode("i", shape=()), tn.AddConstantNode("ac")]), default_hyperparameters={"value": 2}) fn1 = network1.function(["i"], ["ac"]) nt.assert_equal(2, fn1(0)[0]) network2 = canopy.transforms.add_hyperparameters(network1, "hp", dict(value=3)) print(network2.root_node) fn2a = network2.function(["i"], ["ac"]) nt.assert_equal(3, fn2a(0)[0]) fn2b = network2.function(["i"], ["hp"]) nt.assert_equal(3, fn2b(0)[0])
def test_dict_children_container_schema(): dccs = core.DictChildrenContainerSchema( foo=core.ListChildrenContainer, bar=core.ChildContainer, ) node = tn.AddConstantNode("hello") cc1 = dccs({"foo": [node, node], "bar": node}) cc2 = core.children_container._DictChildrenContainerFromSchema({ "foo": core.ListChildrenContainer([node, node]), "bar": core.ChildContainer(node) }) # test that it makes the expected class nt.assert_equal(cc1, cc2)
def forget_gate_conv_2d_node(name, num_filters, filter_size=(3, 3), initial_bias=0): return tn.ElementwiseProductNode(name, [ tn.IdentityNode(name + "_identity"), tn.SequentialNode(name + "_forget", [ tn.Conv2DWithBiasNode(name + "_conv", num_filters=num_filters, filter_size=filter_size, stride=(1, 1), pad="same"), tn.AddConstantNode(name + "_initial_bias", value=initial_bias), tn.SigmoidNode(name + "_sigmoid") ]) ])
def test_graph_node(): network = tn.GraphNode( "g1", [[tn.InputNode("i", shape=()), tn.GraphNode("g2", [(tn.MultiplyConstantNode("m1", value=2), tn.AddConstantNode("a1", value=2)), [{"to": "a1"}, {"from": "a1", "to": "m1"}, {"from": "m1", "to_key": "foo"}]], output_key="foo")], [{"from": "i", "to": "g2"}, {"from": "g2", "to_key": "bar"}]], output_key="bar" ).network() fn = network.function(["i"], ["a1", "m1", "g1", "g2"]) nt.assert_equal([5, 10, 10, 10], fn(3))
def test_remove_nodes(): network1 = tn.SequentialNode("seq", [ tn.InputNode("i", shape=()), tn.HyperparameterNode("hp1", tn.HyperparameterNode( "hp2", tn.AddConstantNode("ac"), value=1), value=2) ]).network() fn1 = network1.function(["i"], ["seq"]) nt.assert_equal(1, fn1(0)[0]) network2 = canopy.transforms.remove_nodes(network1, {"hp2"}, keep_child=True) fn2 = network2.function(["i"], ["seq"]) nt.assert_equal(2, fn2(0)[0]) network3 = canopy.transforms.remove_nodes(network1, {"ac"}) fn3 = network3.function(["i"], ["seq"]) nt.assert_equal(0, fn3(0)[0])
def test_remove_parent(): network1 = tn.SequentialNode("seq", [ tn.InputNode("i", shape=()), tn.HyperparameterNode("hp1", tn.HyperparameterNode( "hp2", tn.AddConstantNode("ac"), value=1), value=2) ]).network() fn1 = network1.function(["i"], ["seq"]) nt.assert_equal(1, fn1(0)[0]) network2 = canopy.transforms.remove_parent(network1, {"ac"}) fn2 = network2.function(["i"], ["seq"]) nt.assert_equal(2, fn2(0)[0]) network3 = canopy.transforms.remove_parent(network1, {"i"}) @nt.raises(Exception) def fails(name): network3.function(["i"], [name]) # testing that these nodes are removed fails("ac") fails("seq") network3.function(["i"], ["i"])
def BiasedDoubleTimesoutNode(name, bias=1, **kwargs): return tn.SequentialNode(name, [ tn.AddConstantNode(name + "_add", value=bias), DoubleTimesoutNode(name + "_to", **kwargs), tn.AddConstantNode(name + "_sub", value=-(bias**2)) ])