def test_contract():
for i in range(5):
x = np.random.randn(2, 2, 2, 2, 2)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(x))
y = np.random.randn(2, 2, 2, 2, 2)
yt = TreeTensor(accuracy=epsilon)
yt.addTensor(ArrayTensor(y))
zt = xt.contract([0, 1, 4], yt, [2, 3, 4])
assert np.sum(
(zt.array - np.einsum('ijklm,qwijm->klqw', x, y))**2) < epsilon
zt = yt.contract([0, 1, 4], xt, [2, 3, 4])
assert np.sum(
(zt.array - np.einsum('ijklm,qwijm->klqw', y, x))**2) < epsilon
for i in range(5):
x = np.random.randn(2, 2, 3, 2, 2)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(x))
y = np.random.randn(3, 2, 2, 2, 2)
yt = TreeTensor(accuracy=epsilon)
yt.addTensor(ArrayTensor(y))
zt = xt.contract([0, 1, 4], yt, [2, 3, 4])
assert np.sum(
(zt.array - np.einsum('ijklm,qwijm->klqw', x, y))**2) < epsilon
def test_pathing():
tn = TreeNetwork(accuracy=epsilon)
n1 = Node(ArrayTensor(np.random.randn(3, 3, 3)))
tn.addNode(n1)
assert len(tn.pathBetween(n1, n1)) == 1
n2 = Node(ArrayTensor(np.random.randn(3, 3, 3)))
Link(n1.buckets[0], n2.buckets[0])
tn.addNode(n2)
assert len(tn.pathBetween(n1, n2)) == 2
assert len(tn.pathBetween(n2, n1)) == 2
assert tn.pathBetween(n1, n2) == [n1, n2]
assert tn.pathBetween(n2, n1) == [n2, n1]
n3 = Node(ArrayTensor(np.random.randn(3, 3, 3)))
Link(n3.buckets[0], n2.buckets[2])
tn.addNode(n3)
assert len(tn.pathBetween(n1, n3)) == 3
assert len(tn.pathBetween(n3, n1)) == 3
assert tn.pathBetween(n1, n3) == [n1, n2, n3]
assert tn.pathBetween(n3, n1) == [n3, n2, n1]
assert tn.pathBetween(n2, n3) == [n2, n3]
assert tn.pathBetween(n3, n2) == [n3, n2]
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_flatten():
for i in range(5):
x = np.random.randn(3, 3, 5)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(x))
assert np.sum(
(xt.flatten([0, 1]).array - np.reshape(x, (-1, 5)).T)**2) < epsilon
for i in range(5):
x = np.random.randn(2, 2, 2, 2, 2, 2)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(x))
assert np.sum(
(xt.flatten([1, 2]).array -
np.transpose(np.reshape(x,
(2, 4, 2, 2, 2)), axes=[0, 2, 3, 4, 1]))**
2) < epsilon
for i in range(5):
x = np.random.randn(2, 2, 2, 2, 2, 2)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(x))
assert np.sum((xt.flatten([2, 1]).array -
np.transpose(np.reshape(np.swapaxes(x, 1, 2),
(2, 4, 2, 2, 2)),
axes=[0, 2, 3, 4, 1]))**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 test_getIndexFactor():
for i in range(5):
x = np.random.randn(3, 3, 3)
xT = ArrayTensor(x)
a, j = xT.getIndexFactor(0)
assert np.sum((x / np.max(np.abs(x)) - a)**2) < epsilon
assert j == 0
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_setIndexFactor():
for i in range(5):
x = np.random.randn(3, 3, 3)
xT = ArrayTensor(x)
y = np.random.randn(3, 3, 3)
assert np.sum(
(xT.setIndexFactor(0, y).array - y * np.exp(xT.logScalar))**
2) < epsilon
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():
for i in range(5):
x = np.random.randn(3, 3, 4)
xt = ArrayTensor(x, logScalar=0)
assert xt.shape == (3, 3, 4)
assert xt.rank == 3
assert xt.size == 3 * 3 * 4
assert np.sum((xt.array - x)**2) < epsilon
assert xt.logScalar == np.log(np.max(np.abs(x)))
assert np.sum((xt.scaledArray - x / np.exp(xt.logScalar))**2) < epsilon
xt2 = ArrayTensor(x, logScalar=1.44)
assert xt2.logScalar == xt.logScalar + 1.44
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 flatten(self, inds):
'''
This method merges the listed external indices using a tree tensor
by attaching the identity tensor to all of them and to a new
external bucket. It then returns the new tree tensor.
'''
buckets = [self.externalBuckets[i] for i in inds]
shape = [self.shape[i] for i in inds]
# Create identity array
shape.append(np.product(shape))
iden = np.identity(shape[-1])
iden = np.reshape(iden, shape)
# Create Tree Tensor holding the identity
tens = ArrayTensor(iden)
tn = TreeTensor(self.accuracy)
tn.addTensor(tens)
# Contract the identity
ttens = self.contract(inds, tn, list(range(len(buckets))))
shape2 = [self.shape[i] for i in range(self.rank) if i not in inds]
shape2.append(shape[-1])
for i in range(len(shape2)):
assert ttens.shape[i] == shape2[i]
return ttens
def test_trace():
for i in range(5):
x = np.random.randn(2, 2, 2, 2, 2, 2)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(x))
assert np.sum((xt.trace([0], [1]).array - np.einsum('iijklm->jklm', x))
**2) < epsilon
assert np.sum(
(xt.trace([0, 2], [5, 4]).array - np.einsum('ijklki->jl', x))**
2) < epsilon
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 test_optimize():
for i in range(5):
x = np.random.randn(2, 2, 2, 2)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(x))
y = np.random.randn(2, 2, 2, 2)
yt = TreeTensor(accuracy=epsilon)
yt.addTensor(ArrayTensor(y))
zt = xt.contract([0], yt, [0])
arr1 = zt.array
zt.optimize()
arr2 = zt.array
assert np.sum((arr1 - arr2)**2) < epsilon
def test_IndexFactor():
for i in range(5):
x = np.random.randn(2, 3, 4, 5)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(x))
y = np.random.randn(2, 3, 4, 5)
yt = TreeTensor(accuracy=epsilon)
yt.addTensor(ArrayTensor(y))
# Compute inner product
zt = xt.contract([0], yt, [0])
# Generate a random unitary matrix
r = np.random.randn(2, 2)
r += r.T
u = expm(1j * r)
# Apply to factors on both x and y
factX, indX = xt.getIndexFactor(0)
factY, indY = yt.getIndexFactor(0)
factX = np.tensordot(factX, u, axes=([indX], [0]))
factY = np.tensordot(factY, np.conjugate(u.T), axes=([indY], [0]))
permX = list(range(len(factX.shape) - 1))
permY = list(range(len(factY.shape) - 1))
permX.insert(indX, len(factX.shape) - 1)
permY.insert(indY, len(factY.shape) - 1)
factX = np.transpose(factX, axes=permX)
factY = np.transpose(factY, axes=permY)
xt = xt.setIndexFactor(0, factX)
yt = yt.setIndexFactor(0, factY)
assert xt.shape == (2, 3, 4, 5)
assert yt.shape == (2, 3, 4, 5)
zt2 = xt.contract([0], yt, [0])
assert np.sum((zt.array - zt2.array)**2) < epsilon
def __init__(self, dimension, rank, accuracy=0.0):
super().__init__(accuracy)
numLayers = layer(dimension)
if rank == 0:
self.addTensor(ArrayTensor(np.array(1.)))
if rank == 1:
self.addTensor(ArrayTensor(np.ones(dimension)))
elif rank == 2:
self.addTensor(ArrayTensor(np.identity(dimension)))
else:
numTensors = rank - 2
buckets = []
# Create identity array
iden = np.zeros((dimension, dimension, dimension))
for i in range(dimension):
iden[i, i, i] = 1.0
for i in range(numTensors):
n = super().addTensor(ArrayTensor(iden))
buckets = buckets + n.buckets
while len(self.network.externalBuckets) > rank:
b = buckets.pop(0)
i = 0
while buckets[i].node is b.node or len(
buckets[i].node.connectedNodes) > 0:
i += 1
Link(b, buckets[i])
self.externalBuckets.remove(b)
self.externalBuckets.remove(buckets[i])
self.network.externalBuckets.remove(b)
self.network.externalBuckets.remove(buckets[i])
self.network.internalBuckets.add(b)
self.network.internalBuckets.add(buckets[i])
buckets.remove(buckets[i])
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_init():
for i in range(5):
x = np.random.randn(3, 3, 4)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(x))
assert xt.shape == (3, 3, 4)
assert xt.rank == 3
assert xt.size == 3 * 3 * 4
assert np.sum((xt.array - x)**2) < epsilon
for i in range(5):
x = np.random.randn(2, 2, 2, 2, 2, 2, 2)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(x))
assert xt.shape == (2, 2, 2, 2, 2, 2, 2)
assert xt.rank == 7
assert xt.size == 2**7
assert np.sum((xt.array - x)**2) < epsilon
def test_IndexFactor():
for i in range(5):
x = np.random.randn(3, 4, 5, 6)
xt = ArrayTensor(x)
y = np.random.randn(3, 4, 5, 6)
yt = ArrayTensor(y)
# Compute inner product
zt = xt.contract([0], yt, [0])
# Generate a random unitary matrix
r = np.random.randn(3, 3)
r += r.T
u = expm(1j * r)
assert np.sum(
(np.identity(3) - np.dot(u, np.conjugate(u.T)))**2) < epsilon
# Apply to factors on both x and y
factX, indX = xt.getIndexFactor(0)
factY, indY = yt.getIndexFactor(0)
factX = np.tensordot(factX, u, axes=([indX], [0]))
factY = np.tensordot(factY, np.conjugate(u.T), axes=([indY], [0]))
factX = np.transpose(factX, axes=[3, 0, 1, 2])
factY = np.transpose(factY, axes=[3, 0, 1, 2])
xt = xt.setIndexFactor(0, factX)
yt = yt.setIndexFactor(0, factY)
assert xt.shape == (3, 4, 5, 6)
assert yt.shape == (3, 4, 5, 6)
zt2 = xt.contract([0], yt, [0])
assert np.sum((zt.array - zt2.array)**2) < epsilon
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 test_trace():
for i in range(5):
x = np.random.randn(3, 3, 5)
xt = ArrayTensor(x)
assert np.sum(
(xt.trace([0], [1]).array - np.einsum('iij->j', x))**2) < epsilon
for i in range(5):
x = np.random.randn(3, 3, 5, 4, 4)
xt = ArrayTensor(x)
assert np.sum(
(xt.trace([0, 3], [1, 4]).array - np.einsum('iijkk->j', x))**
2) < epsilon
def test_flatten():
for i in range(5):
x = np.random.randn(3, 3, 5)
xt = ArrayTensor(x)
assert np.sum(
(xt.flatten([0, 1]).array - np.reshape(x, (-1, 5)).T)**2) < epsilon
for i in range(5):
x = np.random.randn(3, 3, 5)
xt = ArrayTensor(x)
assert np.sum(
(xt.flatten([1, 0]).array - np.reshape(np.swapaxes(x, 0, 1),
(-1, 5)).T)**2) < epsilon
def test_contract():
for i in range(5):
x = np.random.randn(3, 4, 3)
y = np.random.randn(3, 4, 3)
xt = ArrayTensor(x)
yt = ArrayTensor(y)
zt = xt.contract(0, yt, 0)
assert np.sum(
(zt.array - np.einsum('ijk,ilm->jklm', x, y))**2) < epsilon
zt = xt.contract(1, yt, 1)
assert np.sum(
(zt.array - np.einsum('jik,lim->jklm', x, y))**2) < epsilon
zt = xt.contract(0, yt, 2)
assert np.sum(
(zt.array - np.einsum('ijk,lmi->jklm', x, y))**2) < epsilon
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 setIndexFactor(self, ind, arr):
tt = deepcopy(self)
tt.externalBuckets[ind].node.tensor = ArrayTensor(
arr, logScalar=tt.externalBuckets[ind].node.tensor.logScalar)
return tt
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