def test_mergeNode_ArrayTensor(): for i in range(5): net = Network() x = np.random.randn(2, 3, 3) xt = ArrayTensor(x) n1 = Node(xt) xt = ArrayTensor(x) n2 = Node(xt) net.addNode(n1) Link(n1.buckets[0], n2.buckets[0]) net.addNode(n2) net.mergeNodes(n1, n2) assert len(net.nodes) == 1 assert len(net.buckets) == 4 assert len(net.internalBuckets) == 0 assert len(net.externalBuckets) == 4 assert len(net.optimizedLinks) == 0 arr, bdict = net.array assert arr.shape == (3, 3, 3, 3) for b in net.buckets: assert b.id in bdict for b1 in net.buckets: for b2 in net.buckets: if b1.id < b2.id: assert bdict[b1.id] < bdict[b2.id] assert np.sum((arr - np.einsum('ijk,ilm->jklm', x, x))**2) < epsilon
def test_mergeLinks_TreeTensor_Compress(): for i in range(5): net = Network() x = np.random.randn(2, 2, 2, 2, 3, 3) xt = TreeTensor(accuracy=epsilon) xt.addTensor(ArrayTensor(x)) n1 = Node(xt) x = np.random.randn(2, 2, 2, 2, 3, 3) xt = TreeTensor(accuracy=epsilon) xt.addTensor(ArrayTensor(x)) n2 = Node(xt) net.addNode(n1) Link(n1.buckets[0], n2.buckets[0]) Link(n1.buckets[1], n2.buckets[1]) net.addNode(n2) arr1, bdict1 = net.array net.mergeLinks(n1, compress=True, accuracy=epsilon) arr2, bdict2 = net.array assert np.sum((arr1 - arr2)**2) < epsilon assert np.sum((arr1 - arr2)**2) < epsilon
def splitNode(self, node, ignore=None): ''' Takes as input a Node and ensures that it is at most rank 3 by factoring rank 3 tensors out of it until what remains is rank 3. The factoring is done via a greedy algorithm, where the pair of indices with the least correlation with the rest are factored out. This is determined by explicitly tracing out all but those indices from the density matrix and computing the entropy. ignore may be None or a pair of indices. In the latter case, the pair of indices will be required to stay together. This is enforced by having the pair be the first one factored. ''' nodes = [] while node.tensor.rank > 3: self.removeNode(node) array = node.tensor.scaledArray s = [] if ignore is not None: p = ignore ignore = None else: p = entropy(array) u, v, indices1, indices2 = splitArray(array, p, accuracy=self.accuracy) if u.shape[-1] > 1: b1 = Bucket() b2 = Bucket() n1 = Node(ArrayTensor(u, logScalar=node.tensor.logScalar / 2), Buckets=[node.buckets[i] for i in indices1] + [b1]) n2 = Node(ArrayTensor(v, logScalar=node.tensor.logScalar / 2), Buckets=[b2] + [node.buckets[i] for i in indices2]) # This line has to happen before addNode to prevent b1 and b2 # from becoming externalBuckets _ = Link(b1, b2) else: # Cut link u = u[..., 0] v = v[0] n1 = Node(ArrayTensor(u, logScalar=node.tensor.logScalar / 2), Buckets=[node.buckets[i] for i in indices1]) n2 = Node(ArrayTensor(v, logScalar=node.tensor.logScalar / 2), Buckets=[node.buckets[i] for i in indices2]) self.addNode(n1) self.addNode(n2) nodes.append(n1) node = n2 nodes.append(node) return nodes
def test_init(): x = np.random.randn(2, 3, 3) xt = ArrayTensor(x) n = Node(xt) assert len(n.buckets) == xt.rank for i, b in enumerate(n.buckets): assert b.node == n assert b.index == i assert n.bucketIndex(b) == i
def addTensor(self, tensor): n = Node(tensor, Buckets=[Bucket() for _ in range(tensor.rank)]) self.network.addNode(n) self.externalBuckets.extend(n.buckets) if tensor.rank > 3: self.network.splitNode(n) return n
def test_mergeBuckets(): x = np.random.randn(2, 3, 3) xt = ArrayTensor(x) n = Node(xt) buckets = list(n.buckets) b = n.mergeBuckets(n.buckets[1:]) assert n.tensor.rank == 2 assert n.tensor.shape == (2, 9) assert len(n.buckets) == 2 assert n.buckets[0] == buckets[0] assert n.buckets[1] != buckets[1] assert n.buckets[1] == b assert np.sum((np.reshape(x, (-1, 9)) - n.tensor.array)**2) < epsilon x = np.random.randn(2, 3, 3) xt = TreeTensor(accuracy=epsilon) xt.addTensor(ArrayTensor(x)) n = Node(xt) buckets = list(n.buckets) b = n.mergeBuckets(n.buckets[1:]) assert n.tensor.rank == 2 assert n.tensor.shape == (2, 9) assert len(n.buckets) == 2 assert n.buckets[0] == buckets[0] assert n.buckets[1] != buckets[1] assert n.buckets[1] == b assert np.sum((np.reshape(x, (-1, 9)) - n.tensor.array)**2) < epsilon x = np.random.randn(2, 2, 2, 2, 2, 2) xt = TreeTensor(accuracy=epsilon) xt.addTensor(ArrayTensor(x)) n = Node(xt) buckets = list(n.buckets) b = n.mergeBuckets(n.buckets[4:]) assert n.tensor.rank == 5 assert n.tensor.shape == (2, 2, 2, 2, 4) assert len(n.buckets) == 5 assert n.buckets[0] == buckets[0] assert n.buckets[-1] != buckets[-1] assert n.buckets[-1] == b assert np.sum((np.reshape(x, (2, 2, 2, 2, 4)) - n.tensor.array)**2) < epsilon
def test_init(): net = Network() assert len(net.nodes) == 0 assert len(net.buckets) == 0 assert len(net.internalBuckets) == 0 assert len(net.externalBuckets) == 0 assert len(net.optimizedLinks) == 0 x = np.random.randn(2, 3, 3) xt = ArrayTensor(x) n1 = Node(xt) net.addNode(n1) assert len(net.nodes) == 1 assert len(net.buckets) == 3 assert len(net.internalBuckets) == 0 assert len(net.externalBuckets) == 3 assert len(net.optimizedLinks) == 0 x = np.random.randn(2, 3, 3) xt = ArrayTensor(x) n2 = Node(xt) Link(n1.buckets[0], n2.buckets[0]) net.addNode(n2) assert len(net.nodes) == 2 assert len(net.buckets) == 6 assert len(net.internalBuckets) == 2 assert len(net.externalBuckets) == 4 assert len(net.optimizedLinks) == 0 net.removeNode(n1) assert len(net.nodes) == 1 assert len(net.buckets) == 3 assert len(net.internalBuckets) == 0 assert len(net.externalBuckets) == 3 assert len(net.optimizedLinks) == 0
def test_mergeLinks_ArrayTensor(): for i in range(5): net = Network() x = np.random.randn(2, 2, 3, 3) xt = ArrayTensor(x) n1 = Node(xt) xt = ArrayTensor(x) n2 = Node(xt) net.addNode(n1) Link(n1.buckets[0], n2.buckets[0]) Link(n1.buckets[1], n2.buckets[1]) net.addNode(n2) arr1, bdict1 = net.array net.mergeLinks(n1) arr2, bdict2 = net.array assert np.sum((arr1 - arr2)**2) < epsilon assert np.sum((arr1 - arr2)**2) < epsilon
def test_mergeNode_TreeTensor(): for i in range(5): net = Network() x = np.random.randn(2, 2, 2, 2, 2) xt = TreeTensor(accuracy=epsilon) xt.addTensor(ArrayTensor(x)) n1 = Node(xt) y = np.random.randn(2, 2, 2, 2, 2) xt = TreeTensor(accuracy=epsilon) xt.addTensor(ArrayTensor(y)) n2 = Node(xt) net.addNode(n1) Link(n1.buckets[0], n2.buckets[0]) net.addNode(n2) net.mergeNodes(n1, n2) assert len(net.nodes) == 1 assert len(net.buckets) == 8 assert len(net.internalBuckets) == 0 assert len(net.externalBuckets) == 8 assert len(net.optimizedLinks) == 0 arr, bdict = net.array assert arr.shape == (2, 2, 2, 2, 2, 2, 2, 2) for b in net.buckets: assert b.id in bdict for b1 in net.buckets: for b2 in net.buckets: if b1.id < b2.id: assert bdict[b1.id] < bdict[b2.id] assert np.sum( (arr - np.einsum('ijklm,iqwer->jklmqwer', x, y))**2) < epsilon
def mergeNodes(self, n1, n2): ''' Merges the specified Nodes. ''' t, buckets = self.dummyMergeNodes(n1, n2) n = Node(t, Buckets=buckets) # The order matters here: we have to remove the old nodes before # adding the new one to make sure that the correct buckets end up # in the network. self.removeNode(n1) self.removeNode(n2) self.addNode(n) return n
def test_links(): x = np.random.randn(2, 3, 3) xt = ArrayTensor(x) n1 = Node(xt) x = np.random.randn(2, 3, 3) xt = ArrayTensor(x) n2 = Node(xt) l1 = Link(n1.buckets[0], n2.buckets[0]) assert n1.linkedBuckets[0].otherBucket == n2.buckets[0] l2 = Link(n2.buckets[1], n1.buckets[1]) assert n1.linkedBuckets[1].otherBucket == n2.buckets[1] assert l1.bucket1.node == n1 or l1.bucket2.node == n1 assert l1.bucket1.node == n2 or l1.bucket2.node == n2 assert l1 in n1.findLinks(n2) assert l2 in n1.findLinks(n2) assert l1 in n2.findLinks(n1) assert l2 in n2.findLinks(n1) assert n1.findLink(n2) == l1 or n1.findLink(n2) == l2 assert n1.indexConnecting(n2) == 0 or n1.indexConnecting(n2) == 1 assert n2.indexConnecting(n1) == 0 or n2.indexConnecting(n1) == 1 assert 0 in n1.indicesConnecting(n2)[0] assert 1 in n1.indicesConnecting(n2)[0] assert 2 not in n1.indicesConnecting(n2)[0] assert 0 in n2.indicesConnecting(n1)[0] assert 1 in n2.indicesConnecting(n1)[0] assert 2 not in n2.indicesConnecting(n1)[0] assert 0 in n1.indicesConnecting(n2)[1] assert 1 in n1.indicesConnecting(n2)[1] assert 2 not in n1.indicesConnecting(n2)[1] assert 0 in n2.indicesConnecting(n1)[1] assert 1 in n2.indicesConnecting(n1)[1] assert 2 not in n2.indicesConnecting(n1)[1] assert len(n1.connectedNodes) == 1 assert n2 in n1.connectedNodes
def PA2D(nX, nY, h, J, q, accuracy): network = Network() # Place to store the tensors lattice = [[] for i in range(nX)] bondL = [[] for i in range(nX)] # Each lattice site has seven indices of width five, and returns zero if # they are unequal and one otherwise. for i in range(nX): for j in range(nY): lattice[i].append(Node(IdentityTensor(2, 5, accuracy=accuracy))) arr = np.zeros((2, 2)) # 2-point arr[0][0] = np.exp(-J) arr[1][1] = np.exp(-J) arr[0][1] = np.exp(J) arr[1][0] = np.exp(J) # 1-point arr[0] *= np.exp(h / 4) arr[1] *= np.exp(-h / 4) # Expand arr = np.einsum('ij,ik,il,ia->ijkla', arr, arr, arr, arr) # 3-point arr[1, 1, :, 1, :] = 0 arr[1, 1, :, :, 1] = 0 arr[1, :, 1, 1, :] = 0 arr[1, :, 1, :, 1] = 0 # 4-point arr[1, 1, 1, 1, :] = np.exp(q) arr[1, 1, 1, :, 1] = np.exp(q) arr[1, 1, :, 1, 1] = np.exp(q) arr[1, :, 1, 1, 1] = np.exp(q) # 5-point for j in range(2): for k in range(2): for l in range(2): for m in range(2): if j + k + l + m >= 4: arr[1, j, k, l, m] = 0 # Make L-bonds for i in range(nX): for j in range(nY): bondL[i].append(Node(ArrayTensor(arr))) # Attach links for i in range(nX): for j in range(nY): Link(lattice[i][j].buckets[0], bondL[i][j].buckets[0]) Link(lattice[i][j].buckets[1], bondL[(i + 1) % nX][j].buckets[1]) Link(lattice[i][j].buckets[2], bondL[i - 1][j].buckets[2]) Link(lattice[i][j].buckets[3], bondL[i][(j + 1) % nY].buckets[3]) Link(lattice[i][j].buckets[4], bondL[i][j - 1].buckets[4]) # Add to Network for i in range(nX): for j in range(nY): network.addNode(lattice[i][j]) network.addNode(bondL[i][j]) return network
def BayesTest2(observations, discreteG, discreteQ, discreteW, discreteH, accuracy): ''' observations is a list of (k,M) pairs where k is the number of heads and M-k is the number of tails in a repeated Bernoulli coin toss. This model represents the likelihood L = M! p^k (1-p)^(M-k)/(k!(M-k)!) summed over all coins that were observed. Here we model p_i = min(g*h_i + q^w, 1) where each of g, q, w and h_i lie in [0,1] and have uniform priors. g, w and q are global parameters. discrete(G,W,Q) specify the g, w and q values to sample. discreteH is the same for h_i. ''' network = Network() # Local tensors hs = [] for i, obs in enumerate(observations): arr = np.zeros( (len(discreteG), len(discreteQ), len(discreteW), len(discreteH))) for j, gg in enumerate(discreteG): for k, qq in enumerate(discreteQ): for e, ww in enumerate(discreteW): for l, h in enumerate(discreteH): p = min(gg * h + qq**ww, 1) arr[j, k, e, l] = factorial(obs[1]) * p**obs[0] * (1 - p)**( obs[1] - obs[0]) / (factorial(obs[0]) * factorial(obs[1] - obs[0])) # Marginalizes over all of the individual distributions arr = np.sum(arr, axis=-1) h = Node(ArrayTensor(arr)) hs.append(h) extG = [h.buckets[0] for h in hs] extW = [h.buckets[1] for h in hs] extQ = [h.buckets[2] for h in hs] nodes = [] dimension = len(discreteG) while len(extG) > 1: iden = np.zeros((dimension, dimension, dimension)) for i in range(dimension): iden[i, i, i] = 1.0 n = Node(IdentityTensor(dimension, 3, accuracy=accuracy)) nodes.append(n) Link(n.buckets[0], extG[0]) Link(n.buckets[1], extG[1]) extG.append(n.buckets[2]) extG = extG[2:] dimension = len(discreteW) while len(extW) > 1: iden = np.zeros((dimension, dimension, dimension)) for i in range(dimension): iden[i, i, i] = 1.0 n = Node(IdentityTensor(dimension, 3, accuracy=accuracy)) nodes.append(n) Link(n.buckets[0], extW[0]) Link(n.buckets[1], extW[1]) extW.append(n.buckets[2]) extW = extW[2:] dimension = len(discreteQ) while len(extQ) > 1: iden = np.zeros((dimension, dimension, dimension)) for i in range(dimension): iden[i, i, i] = 1.0 n = Node(IdentityTensor(dimension, 3, accuracy=accuracy)) nodes.append(n) Link(n.buckets[0], extQ[0]) Link(n.buckets[1], extQ[1]) extQ.append(n.buckets[2]) extQ = extQ[2:] for h in hs: network.addNode(h) for n in nodes: network.addNode(n) return network
def BayesTest1(observations, discreteG, discreteQ, discreteW, discreteH, accuracy): ''' observations is a list of (k,M) pairs where k is the number of heads and M-k is the number of tails in a repeated Bernoulli coin toss. This model represents the likelihood L = M! p^k (1-p)^(M-k)/(k!(M-k)!) summed over all coins that were observed. Here we model p_i = min(g*h_i + q^w, 1) where each of g, q, w and h_i lie in [0,1] and have uniform priors. g, w and q are global parameters. discrete(G,W,Q) specify the g, w and q values to sample. discreteH is the same for h_i. ''' network = Network() # Global tensors n = len(observations) g = Node(IdentityTensor(len(discreteG), n + 1, accuracy=accuracy)) q = Node(IdentityTensor(len(discreteQ), n + 1, accuracy=accuracy)) w = Node(IdentityTensor(len(discreteW), n + 1, accuracy=accuracy)) # Local tensors hs = [] for i, obs in enumerate(observations): arr = np.zeros( (len(discreteG), len(discreteQ), len(discreteW), len(discreteH))) for j, gg in enumerate(discreteG): for k, qq in enumerate(discreteQ): for e, ww in enumerate(discreteW): for l, h in enumerate(discreteH): p = min(gg * h + qq**ww, 1) arr[j, k, e, l] = factorial(obs[1]) * p**obs[0] * (1 - p)**( obs[1] - obs[0]) / (factorial(obs[0]) * factorial(obs[1] - obs[0])) # Marginalizes over all of the individual distributions arr = np.sum(arr, axis=-1) h = Node(ArrayTensor(arr)) hs.append(h) Link(h.buckets[0], g.buckets[i]) Link(h.buckets[1], q.buckets[i]) Link(h.buckets[2], w.buckets[i]) # Assemble the network network.addNode(g) network.addNode(q) network.addNode(w) for h in hs: network.addNode(h) return network
def PA3D(nX, nY, nZ, h, J, q, accuracy): network = Network() # Place to store the tensors lattice = [[[] for j in range(nY)] for i in range(nX)] bondL = [[[] for j in range(nY)] for i in range(nX)] # Each lattice site has seven indices of width five, and returns zero if # they are unequal and one otherwise. for i in range(nX): for j in range(nY): for k in range(nZ): lattice[i][j].append( Node(IdentityTensor(2, 7, accuracy=accuracy))) arr = np.zeros((2, 2)) # 2-point arr[0][0] = np.exp(-J) arr[1][1] = np.exp(-J) arr[0][1] = np.exp(J) arr[1][0] = np.exp(J) # 1-point arr[0] *= np.exp(h / 6) arr[1] *= np.exp(-h / 6) # Expand arr = np.einsum('ij,ik,il,ia,ib,ic->ijklabc', arr, arr, arr, arr, arr, arr) # 3-point arr[1, 1, :, 1, :, :, :] = 0 arr[1, 1, :, :, 1, :, :] = 0 arr[1, 1, :, :, :, 1, :] = 0 arr[1, 1, :, :, :, :, 1] = 0 arr[1, :, 1, 1, :, :, :] = 0 arr[1, :, 1, :, 1, :, :] = 0 arr[1, :, 1, :, :, 1, :] = 0 arr[1, :, 1, :, :, :, 1] = 0 arr[1, 1, :, 1, :, :, :] = 0 arr[1, :, 1, 1, :, :, :] = 0 arr[1, :, :, 1, :, 1, :] = 0 arr[1, :, :, 1, :, :, 1] = 0 arr[1, 1, :, :, 1, :, :] = 0 arr[1, :, 1, :, 1, :, :] = 0 arr[1, :, :, :, 1, 1, :] = 0 arr[1, :, :, :, 1, :, 1] = 0 arr[1, 1, :, :, :, 1, :] = 0 arr[1, :, 1, :, :, 1, :] = 0 arr[1, :, :, 1, :, 1, :] = 0 arr[1, :, :, :, 1, 1, :] = 0 arr[1, 1, :, :, :, :, 1] = 0 arr[1, :, 1, :, :, :, 1] = 0 arr[1, :, :, 1, :, :, 1] = 0 arr[1, :, :, :, 1, :, 1] = 0 # 4-point arr[1, 1, 1, 1, :, :, :] = np.exp(q) arr[1, 1, 1, :, 1, :, :] = np.exp(q) arr[1, 1, 1, :, :, 1, :] = np.exp(q) arr[1, 1, 1, :, :, :, 1] = np.exp(q) arr[1, 1, :, 1, 1, :, :] = np.exp(q) arr[1, :, 1, 1, 1, :, :] = np.exp(q) arr[1, :, :, 1, 1, 1, :] = np.exp(q) arr[1, :, :, 1, 1, :, 1] = np.exp(q) arr[1, 1, :, :, :, 1, 1] = np.exp(q) arr[1, :, 1, :, :, 1, 1] = np.exp(q) arr[1, :, :, 1, :, 1, 1] = np.exp(q) arr[1, :, :, :, 1, 1, 1] = np.exp(q) # 5-point for j in range(2): for k in range(2): for l in range(2): for m in range(2): for n in range(2): for p in range(2): if j + k + l + m + n + p >= 4: arr[1, j, k, l, m, n, p] = 0 t = ArrayTensor(arr) tt = TreeTensor(accuracy) tt.addTensor(t) # Make L-bonds for i in range(nX): for j in range(nY): for k in range(nZ): bondL[i][j].append(Node(deepcopy(tt))) # Attach links for i in range(nX): for j in range(nY): for k in range(nZ): Link(lattice[i][j][k].buckets[0], bondL[i][j][k].buckets[0]) Link(lattice[i][j][k].buckets[1], bondL[(i + 1) % nX][j][k].buckets[1]) Link(lattice[i][j][k].buckets[2], bondL[i - 1][j][k].buckets[2]) Link(lattice[i][j][k].buckets[3], bondL[i][(j + 1) % nY][k].buckets[3]) Link(lattice[i][j][k].buckets[4], bondL[i][j - 1][k].buckets[4]) Link(lattice[i][j][k].buckets[5], bondL[i][j][(k + 1) % nZ].buckets[5]) Link(lattice[i][j][k].buckets[6], bondL[i][j][k - 1].buckets[6]) # Add to Network for i in range(nX): for j in range(nY): for k in range(nZ): network.addNode(lattice[i][j][k]) network.addNode(bondL[i][j][k]) return network