def test_flatten_consistent_result(self): net_noflat = tensornetwork.TensorNetwork() a_val = np.random.normal(size=(3, 5, 5, 6)) b_val = np.random.normal(size=(5, 6, 4, 5)) # Create non flattened example to compare against. a_noflat = net_noflat.add_node(a_val) b_noflat = net_noflat.add_node(b_val) e1 = net_noflat.connect(a_noflat[1], b_noflat[3]) e2 = net_noflat.connect(a_noflat[3], b_noflat[1]) e3 = net_noflat.connect(a_noflat[2], b_noflat[0]) a_dangling_noflat = a_noflat[0] b_dangling_noflat = b_noflat[2] for edge in [e1, e2, e3]: net_noflat.contract(edge) noflat_result_node = net_noflat.get_final_node() noflat_result_node.reorder_edges( [a_dangling_noflat, b_dangling_noflat]) noflat_result = noflat_result_node.get_tensor().numpy() # Create network with flattening net_flat = tensornetwork.TensorNetwork() a_flat = net_flat.add_node(a_val) b_flat = net_flat.add_node(b_val) e1 = net_flat.connect(a_flat[1], b_flat[3]) e2 = net_flat.connect(a_flat[3], b_flat[1]) e3 = net_flat.connect(a_flat[2], b_flat[0]) a_dangling_flat = a_flat[0] b_dangling_flat = b_flat[2] final_edge = net_flat.flatten_edges([e1, e2, e3]) flat_result_node = net_flat.contract(final_edge) flat_result_node.reorder_edges([a_dangling_flat, b_dangling_flat]) flat_result = flat_result_node.get_tensor().numpy() self.assertAllClose(flat_result, noflat_result)
def test_double_edge_contract(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.eye(2)) e = net.connect(a[0], a[1], name="edge") net.contract(e) with self.assertRaises(ValueError): net.contract(e)
def f(x, n): x_slice = x[:n] net = tensornetwork.TensorNetwork() n1 = net.add_node(x_slice) n2 = net.add_node(x_slice) e = net.connect(n1[0], n2[0]) return net.contract(e).get_tensor()
def _build_network( tensors: Sequence[Union[np.ndarray, tf.Tensor]], network: Sequence[Sequence] ) -> Tuple[tensornetwork.TensorNetwork, Dict[Any, tensornetwork.Edge]]: tn = tensornetwork.TensorNetwork() nodes = [] edges = {} for (i, (tensor, edge_lbls)) in enumerate(zip(tensors, network)): if len(tensor.shape) != len(edge_lbls): raise ValueError( "Incorrect number of edge labels specified tensor {}".format( i)) node = tn.add_node(tensor, name="tensor_{}".format(i)) nodes.append(node) for (axis_num, edge_lbl) in enumerate(edge_lbls): if edge_lbl not in edges: e = node[axis_num] e.set_name(str(edge_lbl)) edges[edge_lbl] = e else: # This will raise an error if the edges are not dangling. e = tn.connect(edges[edge_lbl], node[axis_num], name=str(edge_lbl)) edges[edge_lbl] = e return tn, edges
def test_real_physics_with_tensors(self): # Calcuate the expected value in numpy a_vals = np.ones([2, 3, 4, 5]) b_vals = np.ones([4, 6, 7]) c_vals = np.ones([5, 6, 8]) contract1 = np.tensordot(a_vals, b_vals, [[2], [0]]) contract2 = np.tensordot(c_vals, contract1, [[0], [2]]) final_result = np.trace(contract2, axis1=0, axis2=4) # Build the network net = tensornetwork.TensorNetwork() a = net.add_node(tf.ones([2, 3, 4, 5]), name="T") b = net.add_node(tf.ones([4, 6, 7]), name="A") c = net.add_node(tf.ones([5, 6, 8]), name="B") e1 = net.connect(a[2], b[0], "edge") e2 = net.connect(c[0], a[3], "edge2") e3 = net.connect(b[1], c[1], "edge3") net.check_correct() node_result = net.contract(e1) self.assertAllClose(node_result.get_tensor(), contract1) net.check_correct() node_result = net.contract(e2) self.assertAllClose(node_result.get_tensor(), contract2) net.check_correct() val = net.contract(e3) net.check_correct() self.assertAllClose(val.get_tensor(), final_result)
def test_outer_product_final_nodes_not_contracted(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.ones(2)) b = net.add_node(np.ones(2)) e = net.connect(a[0], b[0]) with self.assertRaises(ValueError): net.outer_product_final_nodes([e])
def f(x, n): x_slice = x[..., :n] net = tensornetwork.TensorNetwork() n1 = net.add_node(x_slice) net.connect(n1[0], n1[2]) net.connect(n1[1], n1[3]) return net.contract(net.flatten_edges_between(n1, n1)).get_tensor()
def test_large_nodes(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.zeros([5, 6, 7, 8, 9]), "a") b = net.add_node(np.zeros([5, 6, 7, 8, 9]), "b") for i in range(5): net.connect(a[i], b[i]) net.check_correct()
def test_edge_not_in_network(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.eye(2)) b = net.add_node(np.eye(2)) edge = net.connect(a[0], b[0]) net.disconnect(edge) self.assertNotIn(edge, net)
def test_has_nondangling_edge(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.ones(2)) self.assertFalse(a.has_nondangling_edge()) b = net.add_node(np.ones((2, 2))) net.connect(b[0], b[1]) self.assertTrue(b.has_nondangling_edge())
def test_trace_edge_ordering(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.zeros((2, 2, 3))) e2 = net.connect(a[1], a[0]) e3 = a[2] with self.assertRaises(ValueError): a.reorder_edges([e2, e3])
def test_double_edge_axis(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.array([2]), name="a") b = net.add_node(np.array([2]), name="b") net.connect(a[0], b[0]) with self.assertRaises(ValueError): net.connect(a[0], b[0])
def test_bad_trace_contract(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.array([2])) b = net.add_node(np.array([2])) e = net.connect(a[0], b[0]) with self.assertRaises(ValueError): net._contract_trace(e)
def test_outer_product_final_nodes(self): net = tensornetwork.TensorNetwork() edges = [] for i in range(1, 5): edges.append(net.add_node(tf.ones(i))[0]) final_node = net.outer_product_final_nodes(edges) self.assertAllClose(final_node.get_tensor(), np.ones([1, 2, 3, 4])) self.assertEqual(final_node.get_all_edges(), edges)
def test_contract_between_no_outer_product(self): net = tensornetwork.TensorNetwork() a_val = np.random.normal(size=(2, 3, 4)) b_val = np.random.normal(size=(5, 6, 7)) a = net.add_node(a_val) b = net.add_node(b_val) with self.assertRaises(ValueError): net.contract_between(a, b)
def test_contract_between_outer_product(self): net = tensornetwork.TensorNetwork() a_val = np.random.normal(size=(2, 3, 4)) b_val = np.random.normal(size=(5, 6, 7)) a = net.add_node(a_val) b = net.add_node(b_val) c = net.contract_between(a, b, allow_outer_product=True) self.assertEqual(c.get_tensor().shape, (2, 3, 4, 5, 6, 7))
def test_merge_networks(self): net1 = tensornetwork.TensorNetwork() net2 = tensornetwork.TensorNetwork() a = net1.add_node(np.eye(2) * 2) b = net1.add_node(np.eye(2) * 3) e1 = net1.connect(a[0], b[0]) c = net2.add_node(np.eye(2) * 4) net3 = tensornetwork.TensorNetwork.merge_networks([net1, net2]) self.assertIn(a, net3.nodes_set) self.assertIn(b, net3.nodes_set) e2 = net3.connect(c[0], a[1]) e3 = net3.connect(c[1], b[1]) net3.check_correct() for edge in [e1, e2, e3]: net3.contract(edge) result = net3.get_final_node() self.assertAllClose(result.get_tensor().numpy(), 48.0)
def test_node2_contract_trace(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.zeros([3, 3, 1])) b = net.add_node(np.zeros([1])) net.connect(b[0], a[2]) trace_edge = net.connect(a[0], a[1]) net._contract_trace(trace_edge) net.check_correct()
def test_mismatch_edge_ordering(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.zeros((2, 3))) e2_a = a[0] b = net.add_node(np.zeros((2, ))) e_b = b[0] with self.assertRaises(ValueError): a.reorder_edges([e2_a, e_b])
def test_contract_fall_through_name(self): net = tensornetwork.TensorNetwork() node = net.add_node(np.eye(2), name="Identity Matrix") self.assertEqual(node.name, "Identity Matrix") edge = net.connect(node[0], node[1], name="Trace Edge") self.assertEqual(edge.name, "Trace Edge") final_result = net.contract(edge, name="Trace Of Identity") self.assertEqual(final_result.name, "Trace Of Identity")
def test_direct_trace(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.ones([10, 10]), name="a") edge = net.connect(a[0], a[1], "edge") net.check_correct() result = net._contract_trace(edge) net.check_correct() self.assertAlmostEqual(result.get_tensor().numpy(), 10.0)
def test_small_matmul(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.zeros([10, 10]), name="a") b = net.add_node(np.zeros([10, 10]), name="b") edge = net.connect(a[0], b[0], "edge") net.check_correct() c = net.contract(edge, name="a * b") self.assertEqual(c.get_tensor().shape, [10, 10]) net.check_correct()
def test_add_subnetwork(self): net1 = tensornetwork.TensorNetwork() net2 = tensornetwork.TensorNetwork() a = net1.add_node(np.eye(2) * 2) b = net1.add_node(np.eye(2) * 3) e1 = net1.connect(a[0], b[0]) c = net2.add_node(np.eye(2) * 4) net2.add_subnetwork(net1) self.assertIn(a, net2.nodes_set) self.assertIn(b, net2.nodes_set) e2 = net2.connect(c[0], a[1]) e3 = net2.connect(c[1], b[1]) net2.check_correct() self.assertEqual(net2.edge_order, [e1, e2, e3]) for edge in [e1, e2, e3]: net2.contract(edge) result = net2.get_final_node() self.assertAllClose(result.get_tensor().numpy(), 48.0)
def test_contract_parallel(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.eye(2)) b = net.add_node(np.eye(2)) edge1 = net.connect(a[0], b[0]) edge2 = net.connect(a[1], b[1]) c = net.contract_parallel(edge1) self.assertNotIn(edge2, net) self.assertAllClose(c.get_tensor(), 2.0)
def test_single_contract(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.array([1.0] * 5), "a") b = net.add_node(np.array([1.0] * 5), "b") e = net.connect(a[0], b[0]) c = net.contract(e) net.check_correct() val = c.get_tensor().numpy() self.assertAlmostEqual(val, 5.0)
def test_set_node2(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.eye(2)) b = net.add_node(np.eye(2)) e = net.connect(a[0], b[0]) # You should never do this, but if you do, we should handle # it gracefully. e.node2 = None self.assertTrue(e.is_dangling())
def test_contract_between_trace_edges(self): net = tensornetwork.TensorNetwork() a_val = np.random.normal(size=(3, 3)) final_val = np.trace(a_val) a = net.add_node(a_val) net.connect(a[0], a[1]) b = net.contract_between(a, a) net.check_correct() self.assertAllClose(b.get_tensor().numpy(), final_val)
def test_get_all_nondangling(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.eye(2)) b = net.add_node(np.eye(2)) edge1 = net.connect(a[0], b[0]) c = net.add_node(np.eye(2)) d = net.add_node(np.eye(2)) edge2 = net.connect(c[0], d[0]) edge3 = net.connect(a[1], c[1]) self.assertEqual({edge1, edge2, edge3}, net.get_all_nondangling())
def test_flatten_edges_different_nodes(self): net = tensornetwork.TensorNetwork() a = net.add_node(np.eye(2)) b = net.add_node(np.eye(2)) c = net.add_node(np.eye(2)) e1 = net.connect(a[0], b[0]) e2 = net.connect(a[1], c[0]) net.connect(b[1], c[1]) with self.assertRaises(ValueError): net.flatten_edges([e1, e2])
def test_flatten_trace_consistent_result(self): net_noflat = tensornetwork.TensorNetwork() a_val = np.random.normal(size=(5, 6, 6, 7, 5, 7)) a_noflat = net_noflat.add_node(a_val) e1 = net_noflat.connect(a_noflat[0], a_noflat[4]) e2 = net_noflat.connect(a_noflat[1], a_noflat[2]) e3 = net_noflat.connect(a_noflat[3], a_noflat[5]) for edge in [e1, e2, e3]: net_noflat.contract(edge) noflat_result = net_noflat.get_final_node().get_tensor().numpy() # Create network with flattening net_flat = tensornetwork.TensorNetwork() a_flat = net_flat.add_node(a_val) e1 = net_flat.connect(a_flat[0], a_flat[4]) e2 = net_flat.connect(a_flat[1], a_flat[2]) e3 = net_flat.connect(a_flat[3], a_flat[5]) final_edge = net_flat.flatten_edges([e1, e2, e3]) flat_result = net_flat.contract(final_edge).get_tensor().numpy() self.assertAllClose(flat_result, noflat_result)