def test_to_preallocated_init1(): network1 = tn.SequentialNode( "seq", [tn.InputNode("i", shape=(3, 4, 5)), tn.LinearMappingNode( "lm", output_dim=15, inits=[treeano.inits.NormalWeightInit(15.0)])] ).network() inits = [canopy.network_utils.to_preallocated_init(network1)] network2 = tn.SequentialNode( "seq", [tn.InputNode("i", shape=(3, 4, 5)), tn.LinearMappingNode( "lm", output_dim=15, inits=inits)] ).network() w1 = list(canopy.network_utils.to_shared_dict(network1).values())[0] w2 = list(canopy.network_utils.to_shared_dict(network2).values())[0] # both networks should be using the exact same shared variables assert w1 is w2 fn1 = network1.function(["i"], ["lm"]) fn2 = network2.function(["i"], ["lm"]) x = np.random.randn(3, 4, 5).astype(fX) np.testing.assert_equal(fn1(x), fn2(x))
def test_to_shared_dict_relative_network(): network = tn.SequentialNode( "seq", [tn.InputNode("i", shape=(10,)), tn.LinearMappingNode("lm1", output_dim=15), tn.LinearMappingNode("lm2", output_dim=15)] ).network() nt.assert_equal({"lm1:weight", "lm2:weight"}, set(canopy.network_utils.to_shared_dict(network))) nt.assert_equal({"lm1:weight"}, set(canopy.network_utils.to_shared_dict(network["lm1"]))) nt.assert_equal({"lm2:weight"}, set(canopy.network_utils.to_shared_dict(network["lm2"])))
def test_transform_root_node(): network1 = tn.toy.ConstantUpdaterNode( "cun", tn.SequentialNode("seq", [ tn.InputNode("i", shape=(3, 4, 5)), tn.LinearMappingNode("lm", output_dim=15, inits=[treeano.inits.NormalWeightInit(15.0)]) ]), value=-0.1, ).network() # perform build eagerly to initialize weights network1.build() network2 = canopy.transforms.transform_root_node(network1, fn=lambda x: x) fn1 = network1.function(["i"], ["lm"]) fn2 = network2.function(["i"], ["lm"]) fn1u = network1.function(["i"], ["lm"], include_updates=True) fn2u = network2.function(["i"], ["lm"], include_updates=True) x = np.random.randn(3, 4, 5).astype(fX) np.testing.assert_equal(fn1(x), fn2(x)) fn1u(x) np.testing.assert_equal(fn1(x), fn2(x)) fn2u(x) np.testing.assert_equal(fn1(x), fn2(x))
def test_load_value_dict_not_strict_keys(): n1 = tn.SequentialNode( "seq", [tn.InputNode("i", shape=(10, 100)), tn.LinearMappingNode( "lm", output_dim=15, inits=[treeano.inits.NormalWeightInit()])] ).network() n2 = tn.InputNode("i", shape=()).network() def test1(strict_keys): canopy.network_utils.load_value_dict( n1, canopy.network_utils.to_value_dict(n2), strict_keys=strict_keys) def test2(strict_keys): canopy.network_utils.load_value_dict( n2, canopy.network_utils.to_value_dict(n1), strict_keys=strict_keys) nt.raises(AssertionError)(test1)(strict_keys=True) nt.raises(AssertionError)(test2)(strict_keys=True) test1(strict_keys=False) test2(strict_keys=False)
def test_override_hyperparameters2(): network = tn.toy.ConstantUpdaterNode( "cun", tn.SequentialNode("seq", [ tn.InputNode("i", shape=(3, 4, 5)), tn.LinearMappingNode("lm", output_dim=15, inits=[treeano.inits.NormalWeightInit(15.0)]) ]), value=-0.1, ).network() fn1 = network.function(["i"], ["lm"]) fn1u = network.function(["i"], ["lm"], include_updates=True) fn2_args = (network, [canopy.handlers.override_hyperparameters(value=2)], { "x": "i" }, { "out": "lm" }) fn2 = canopy.handlers.handled_fn(*fn2_args) fn2u = canopy.handlers.handled_fn(*fn2_args, include_updates=True) x = np.random.randn(3, 4, 5).astype(fX) np.testing.assert_equal(fn1(x)[0], fn2({"x": x})["out"]) fn1u(x) np.testing.assert_equal(fn1(x)[0], fn2({"x": x})["out"]) fn2u({"x": x}) np.testing.assert_equal(fn1(x)[0], fn2({"x": x})["out"])
def get_shapes(output_dim): network = tn.SequentialNode("s", [ tn.InputNode("in", shape=(3, 4, 5)), tn.LinearMappingNode("linear", output_dim=output_dim), ]).network() weight_shape = network["linear"].get_vw("weight").shape output_shape = network["s"].get_vw("default").shape return weight_shape, output_shape
def new_network(): return tn.SequentialNode( "seq", [tn.InputNode("i", shape=(10, 100)), tn.LinearMappingNode( "lm", output_dim=15, inits=[treeano.inits.NormalWeightInit()])] ).network()
def test_to_value_dict(): network = tn.SequentialNode( "seq", [tn.InputNode("i", shape=(10,)), tn.LinearMappingNode( "lm", output_dim=15, inits=[treeano.inits.ConstantInit(42.42)])] ).network() sd = canopy.network_utils.to_value_dict(network) nt.assert_equal(["lm:weight"], list(sd.keys())) np.testing.assert_equal(42.42 * np.ones((10, 15), dtype=fX), sd["lm:weight"])
def test_to_preallocated_init2(): # test that networks are kept in sync even when updating network1 = tn.toy.ConstantUpdaterNode( "cun", tn.SequentialNode( "seq", [tn.InputNode("i", shape=(3, 4, 5)), tn.LinearMappingNode( "lm", output_dim=15, inits=[treeano.inits.NormalWeightInit(15.0)])]), value=-0.1, ).network() inits = [canopy.network_utils.to_preallocated_init(network1)] network2 = tn.toy.ConstantUpdaterNode( "cun", tn.SequentialNode( "seq", [tn.InputNode("i", shape=(3, 4, 5)), tn.LinearMappingNode( "lm", output_dim=15, inits=inits)]), value=0.4, ).network() fn1 = network1.function(["i"], ["lm"]) fn2 = network2.function(["i"], ["lm"]) fn1u = network1.function(["i"], ["lm"], include_updates=True) fn2u = network2.function(["i"], ["lm"], include_updates=True) x = np.random.randn(3, 4, 5).astype(fX) np.testing.assert_equal(fn1(x), fn2(x)) fn1u(x) np.testing.assert_equal(fn1(x), fn2(x)) fn2u(x) np.testing.assert_equal(fn1(x), fn2(x))
def test_linear_mapping_node(): network = tn.SequentialNode("s", [ tn.InputNode("in", shape=(3, 4, 5)), tn.LinearMappingNode("linear", output_dim=6), ]).network() weight_var = network["linear"].get_vw("weight") fn = network.function(["in"], ["s"]) x = np.random.randn(3, 4, 5).astype(fX) W = np.random.randn(5, 6).astype(fX) # test that weight is 0 initially np.testing.assert_allclose(fn(x)[0], np.zeros((3, 4, 6))) # set weight_var value to new value weight_var.value = W # test that adding works np.testing.assert_allclose(np.dot(x, W), fn(x)[0], rtol=1e-4, atol=1e-7)
def test_pickle_unpickle_network(): temp_dir = tempfile.mkdtemp() dirname = os.path.join(temp_dir, "network") try: n1 = tn.SequentialNode("seq", [ tn.InputNode("i", shape=(10, 100)), tn.LinearMappingNode( "lm", output_dim=15, inits=[treeano.inits.NormalWeightInit()]) ]).network() fn1 = n1.function(["i"], ["lm"]) x = np.random.randn(10, 100).astype(fX) canopy.serialization.pickle_network(n1, dirname) n2 = canopy.serialization.unpickle_network(dirname) fn2 = n2.function(["i"], ["lm"]) np.testing.assert_equal(fn1(x), fn2(x)) finally: shutil.rmtree(temp_dir)
def test_monitor_update_ratio_node(): network = tn.WeightDecayNode( "decay", monitor_update_ratio.MonitorUpdateRatioNode( "mur", tn.SequentialNode( "s", [tn.InputNode("i", shape=(None, 3)), tn.LinearMappingNode("linear", output_dim=10), tn.AddBiasNode("bias")])), weight_decay=1 ).network() network.build() mur_net = network["mur"] vws = mur_net.find_vws_in_subtree(tags={"monitor"}) assert len(vws) == 1 vw, = vws assert re.match(".*_2-norm$", vw.name) assert re.match(".*linear.*", vw.name) assert not re.match(".*bias.*", vw.name)
def test_transform_root_node_postwalk(): network1 = tn.toy.ConstantUpdaterNode( "cun", tn.SequentialNode("seq", [ tn.InputNode("i", shape=(3, 4, 5)), tn.LinearMappingNode("lm", output_dim=15, inits=[treeano.inits.NormalWeightInit(15.0)]) ]), value=-0.1, ).network() def log_name(node): all_names.append(node.name) return node all_names = [] canopy.transforms.transform_root_node_postwalk(network1, log_name) nt.assert_equal(all_names, ["i", "lm", "seq", "cun"]) def append_name(node): # NOTE: assumes NodeImpl subclass node = treeano.node_utils.copy_node(node) node._name += "_1" return node network2 = canopy.transforms.transform_root_node_postwalk( network1, append_name) all_names = [] canopy.transforms.transform_root_node_postwalk(network2, log_name) nt.assert_equal(all_names, ["i_1", "lm_1", "seq_1", "cun_1"]) # assert unmodified all_names = [] canopy.transforms.transform_root_node_postwalk(network1, log_name) nt.assert_equal(all_names, ["i", "lm", "seq", "cun"])
for _ in range(batch_size): i, o = binary_toy_data(lag, length) inputs.append(i) outputs.append(o) return np.array(inputs)[..., np.newaxis], np.array(outputs)[..., np.newaxis] # ############################## prepare model ############################## model = tn.HyperparameterNode( "model", tn.SequentialNode( "seq", [tn.InputNode("x", shape=(None, None, 1)), recurrent_hc.GRUNode("gru1"), tn.LinearMappingNode("y_linear", output_dim=1), tn.AddBiasNode("y_bias", broadcastable_axes=(0, 1)), tn.SigmoidNode("sigmoid"), ]), inits=[treeano.inits.OrthogonalInit()], num_units=HIDDEN_STATE_SIZE, learn_init=True, grad_clip=1, ) with_updates = tn.HyperparameterNode( "with_updates", tn.AdamNode( "adam", {"subtree": model, "cost": tn.TotalCostNode("cost", {
def test_linear_mapping_node_serialization(): tn.check_serialization(tn.LinearMappingNode("a")) tn.check_serialization(tn.LinearMappingNode("a", output_dim=3))